Coverage Report

Created: 2022-12-14 13:11

/Users/davisp/github/tiledb/tiledb/tiledb/api/c_api_support/exception_wrapper/exception_wrapper.h
Line
Count
Source (jump to first uncovered line)
1
/**
2
 * @file tiledb/api/c_api_support/exception_wrapper/exception_wrapper.h
3
 *
4
 * @section LICENSE
5
 *
6
 * The MIT License
7
 *
8
 * @copyright Copyright (c) 2021-2022 TileDB, Inc.
9
 *
10
 * Permission is hereby granted, free of charge, to any person obtaining a copy
11
 * of this software and associated documentation files (the "Software"), to deal
12
 * in the Software without restriction, including without limitation the rights
13
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
14
 * copies of the Software, and to permit persons to whom the Software is
15
 * furnished to do so, subject to the following conditions:
16
 *
17
 * The above copyright notice and this permission notice shall be included in
18
 * all copies or substantial portions of the Software.
19
 *
20
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
23
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
24
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
25
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
26
 * THE SOFTWARE.
27
 *
28
 * @section DESCRIPTION
29
 *
30
 * This file defines templates that wrap an API function with exception
31
 * handlers.
32
 */
33
34
#ifndef TILEDB_C_API_SUPPORT_EXCEPTION_WRAPPER_H
35
#define TILEDB_C_API_SUPPORT_EXCEPTION_WRAPPER_H
36
37
#include <utility>                   // std::forward
38
#include "../argument_validation.h"  // CAPIStatusException
39
#include "tiledb/api/c_api/api_external_common.h"
40
#include "tiledb/api/c_api/context/context_api_internal.h"
41
#include "tiledb/api/c_api/error/error_api_internal.h"
42
#include "tiledb/common/exception/exception.h"
43
#include "tiledb/common/exception/status.h"
44
45
namespace tiledb::api {
46
47
/*
48
 * Top-level exception handling.
49
 *
50
 * Responsibilities of the exception wrappers:
51
 * - Ensure that no exception propagates out of the C API
52
 * - Provide uniform treatment of errors caught at the top level
53
 *
54
 * Actions taken for each exception:
55
 * - Generate a `Status` from an exception object
56
 *   - std::bad_alloc -> "Out of memory" + what()
57
 *   - std::exception -> "uncaught exception" + what()
58
 *   - StatusException -> extract_status()
59
 *   - other -> "uncaught unknown exception"
60
 * - Log the `Status`
61
 * - (optional) Save the error to a context
62
 * - (optional) Pass the error back through an error argument
63
 *
64
 * We use `Status` here primarily out of convenience, even though it should be
65
 * considered a legacy class. It does, however, provide useful informtion, as it
66
 * separates the site (coarsely construed) where the error occurred from the
67
 * error message itself. Thus `StatusException` generated within the code have
68
 * their own sites. We designate standard library exceptions caught at the top
69
 * level with site "C API".
70
 *
71
 * We'll have to stop using `Status` when we all support for nested exceptions.
72
 * At that point the simple strings of `Status` won't suffice to capture the
73
 * sequence-like nature of nested exceptions.
74
 */
75
76
61
inline Status CAPIStatusError(const std::string& msg) {
77
61
  return {"C API", msg};
78
61
};
79
80
namespace detail {
81
82
/**
83
 * Generic class for exception actions; only implemented as specializations.
84
 *
85
 * A fully instantiated class has a member function `action` that runs all the
86
 * `action` member functions of the actions in each class argument in sequence.
87
 *
88
 * @tparam n The number of arguments in the parameter pack A
89
 * @tparam A A list of action classes
90
 */
91
template <class... A>
92
class ExceptionActionImpl;
93
94
/**
95
 * The recursive case inherits from both the first element and this class whose
96
 * template argument has the first element removed.
97
 *
98
 * The effect of this on a fully-instantiated class is that it inherits
99
 * simultaneously from all its template arguments. `action...()` and
100
 * `validate()` are combined appropriately. Other name conflicts will lead to
101
 * ambiguity.
102
 *
103
 * @tparam Head The first action class
104
 * @tparam Tail A list of any remaining action classes
105
 */
106
template <class Head, class... Tail>
107
class ExceptionActionImpl<Head, Tail...> : public Head,
108
                                           public ExceptionActionImpl<Tail...> {
109
 public:
110
  explicit ExceptionActionImpl(Head&& head, Tail&&... tail) noexcept
111
      : Head(head)
112
9.68M
      , ExceptionActionImpl<Tail...>{std::forward<Tail>(tail)...} {
113
9.68M
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::LogAction>::ExceptionActionImpl(tiledb::api::detail::LogAction&&)
Line
Count
Source
112
262k
      , ExceptionActionImpl<Tail...>{std::forward<Tail>(tail)...} {
113
262k
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::LogAction, tiledb::api::detail::ContextAction>::ExceptionActionImpl(tiledb::api::detail::LogAction&&, tiledb::api::detail::ContextAction&&)
Line
Count
Source
112
4.67M
      , ExceptionActionImpl<Tail...>{std::forward<Tail>(tail)...} {
113
4.67M
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::ContextAction>::ExceptionActionImpl(tiledb::api::detail::ContextAction&&)
Line
Count
Source
112
4.67M
      , ExceptionActionImpl<Tail...>{std::forward<Tail>(tail)...} {
113
4.67M
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::LogAction, tiledb::api::detail::ErrorAction>::ExceptionActionImpl(tiledb::api::detail::LogAction&&, tiledb::api::detail::ErrorAction&&)
Line
Count
Source
112
40.1k
      , ExceptionActionImpl<Tail...>{std::forward<Tail>(tail)...} {
113
40.1k
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::ErrorAction>::ExceptionActionImpl(tiledb::api::detail::ErrorAction&&)
Line
Count
Source
112
40.1k
      , ExceptionActionImpl<Tail...>{std::forward<Tail>(tail)...} {
113
40.1k
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::LogAction, tiledb::api::detail::ContextAction, tiledb::api::detail::ErrorAction>::ExceptionActionImpl(tiledb::api::detail::LogAction&&, tiledb::api::detail::ContextAction&&, tiledb::api::detail::ErrorAction&&)
Line
Count
Source
112
5
      , ExceptionActionImpl<Tail...>{std::forward<Tail>(tail)...} {
113
5
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::ContextAction, tiledb::api::detail::ErrorAction>::ExceptionActionImpl(tiledb::api::detail::ContextAction&&, tiledb::api::detail::ErrorAction&&)
Line
Count
Source
112
5
      , ExceptionActionImpl<Tail...>{std::forward<Tail>(tail)...} {
113
5
  }
114
  /**
115
   * Action to take upon catching an exception.
116
   *
117
   * @param st A `Status` that captures the content of an exception.
118
   */
119
1.81k
  inline void action(const Status& st) {
120
1.81k
    Head::action(st);
121
1.81k
    ExceptionActionImpl<Tail...>::action(st);
122
1.81k
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::LogAction>::action(tiledb::common::Status const&)
Line
Count
Source
119
36
  inline void action(const Status& st) {
120
36
    Head::action(st);
121
36
    ExceptionActionImpl<Tail...>::action(st);
122
36
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::LogAction, tiledb::api::detail::ContextAction>::action(tiledb::common::Status const&)
Line
Count
Source
119
832
  inline void action(const Status& st) {
120
832
    Head::action(st);
121
832
    ExceptionActionImpl<Tail...>::action(st);
122
832
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::ContextAction>::action(tiledb::common::Status const&)
Line
Count
Source
119
832
  inline void action(const Status& st) {
120
832
    Head::action(st);
121
832
    ExceptionActionImpl<Tail...>::action(st);
122
832
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::LogAction, tiledb::api::detail::ErrorAction>::action(tiledb::common::Status const&)
Line
Count
Source
119
53
  inline void action(const Status& st) {
120
53
    Head::action(st);
121
53
    ExceptionActionImpl<Tail...>::action(st);
122
53
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::ErrorAction>::action(tiledb::common::Status const&)
Line
Count
Source
119
57
  inline void action(const Status& st) {
120
57
    Head::action(st);
121
57
    ExceptionActionImpl<Tail...>::action(st);
122
57
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::LogAction, tiledb::api::detail::ContextAction, tiledb::api::detail::ErrorAction>::action(tiledb::common::Status const&)
Line
Count
Source
119
4
  inline void action(const Status& st) {
120
4
    Head::action(st);
121
4
    ExceptionActionImpl<Tail...>::action(st);
122
4
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::ContextAction, tiledb::api::detail::ErrorAction>::action(tiledb::common::Status const&)
Line
Count
Source
119
4
  inline void action(const Status& st) {
120
4
    Head::action(st);
121
4
    ExceptionActionImpl<Tail...>::action(st);
122
4
  }
123
  /**
124
   * Action to take when no exception was caught.
125
   */
126
9.68M
  inline void action_on_success() {
127
9.68M
    Head::action_on_success();
128
9.68M
    ExceptionActionImpl<Tail...>::action_on_success();
129
9.68M
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::LogAction>::action_on_success()
Line
Count
Source
126
262k
  inline void action_on_success() {
127
262k
    Head::action_on_success();
128
262k
    ExceptionActionImpl<Tail...>::action_on_success();
129
262k
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::LogAction, tiledb::api::detail::ContextAction>::action_on_success()
Line
Count
Source
126
4.67M
  inline void action_on_success() {
127
4.67M
    Head::action_on_success();
128
4.67M
    ExceptionActionImpl<Tail...>::action_on_success();
129
4.67M
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::ContextAction>::action_on_success()
Line
Count
Source
126
4.67M
  inline void action_on_success() {
127
4.67M
    Head::action_on_success();
128
4.67M
    ExceptionActionImpl<Tail...>::action_on_success();
129
4.67M
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::LogAction, tiledb::api::detail::ErrorAction>::action_on_success()
Line
Count
Source
126
40.0k
  inline void action_on_success() {
127
40.0k
    Head::action_on_success();
128
40.0k
    ExceptionActionImpl<Tail...>::action_on_success();
129
40.0k
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::ErrorAction>::action_on_success()
Line
Count
Source
126
40.0k
  inline void action_on_success() {
127
40.0k
    Head::action_on_success();
128
40.0k
    ExceptionActionImpl<Tail...>::action_on_success();
129
40.0k
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::LogAction, tiledb::api::detail::ContextAction, tiledb::api::detail::ErrorAction>::action_on_success()
Line
Count
Source
126
1
  inline void action_on_success() {
127
1
    Head::action_on_success();
128
1
    ExceptionActionImpl<Tail...>::action_on_success();
129
1
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::ContextAction, tiledb::api::detail::ErrorAction>::action_on_success()
Line
Count
Source
126
1
  inline void action_on_success() {
127
1
    Head::action_on_success();
128
1
    ExceptionActionImpl<Tail...>::action_on_success();
129
1
  }
130
  /**
131
   * Validation action.
132
   */
133
9.68M
  inline void validate() {
134
9.68M
    Head::validate();
135
9.68M
    ExceptionActionImpl<Tail...>::validate();
136
9.68M
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::LogAction>::validate()
Line
Count
Source
133
262k
  inline void validate() {
134
262k
    Head::validate();
135
262k
    ExceptionActionImpl<Tail...>::validate();
136
262k
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::LogAction, tiledb::api::detail::ContextAction>::validate()
Line
Count
Source
133
4.67M
  inline void validate() {
134
4.67M
    Head::validate();
135
4.67M
    ExceptionActionImpl<Tail...>::validate();
136
4.67M
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::ContextAction>::validate()
Line
Count
Source
133
4.67M
  inline void validate() {
134
4.67M
    Head::validate();
135
4.67M
    ExceptionActionImpl<Tail...>::validate();
136
4.67M
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::LogAction, tiledb::api::detail::ErrorAction>::validate()
Line
Count
Source
133
40.1k
  inline void validate() {
134
40.1k
    Head::validate();
135
40.1k
    ExceptionActionImpl<Tail...>::validate();
136
40.1k
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::ErrorAction>::validate()
Line
Count
Source
133
40.1k
  inline void validate() {
134
40.1k
    Head::validate();
135
40.1k
    ExceptionActionImpl<Tail...>::validate();
136
40.1k
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::LogAction, tiledb::api::detail::ContextAction, tiledb::api::detail::ErrorAction>::validate()
Line
Count
Source
133
4
  inline void validate() {
134
4
    Head::validate();
135
4
    ExceptionActionImpl<Tail...>::validate();
136
4
  }
tiledb::api::detail::ExceptionActionImpl<tiledb::api::detail::ContextAction, tiledb::api::detail::ErrorAction>::validate()
Line
Count
Source
133
4
  inline void validate() {
134
4
    Head::validate();
135
4
    ExceptionActionImpl<Tail...>::validate();
136
4
  }
137
};
138
139
/**
140
 * The trivial case with no action class arguments has an empty action.
141
 */
142
template <>
143
class ExceptionActionImpl<> {
144
 public:
145
  ExceptionActionImpl() = default;
146
925
  inline void action(const Status&) {
147
925
  }
148
4.97M
  inline void action_on_success() {
149
4.97M
  }
150
4.97M
  inline void validate() {
151
4.97M
  }
152
};
153
154
/*
155
 * In C++20, we'd define a concept for the action classes. Informally, they
156
 * define three functions:
157
 * - validate(). Checks the validity of constructor arguments.
158
 * - action(). Action to take on exception.
159
 * - action_on_success(). Action to take when there's no exception.
160
 *
161
 * Note that `validate()` looks a lot like a second-state initialization. That's
162
 * because it is. The action classes cannot be C.41-compliant and throw errors
163
 * on construction, because they're implementing the top-level exception
164
 * handler. If they threw errors on construction, it would be outside the
165
 * wrapper function and they'd propagate errors to the calling "C" application.
166
 * On the other hand, `validate()` is called within the wrapper.
167
 *
168
 * Even though `validate()` is called after construction, each component action
169
 * should know its validity at the time of construction. `validate()` should be
170
 * considered an opportunity to report invalidaty by throwing, since these
171
 * constructors cannot throw. Furthermore, if `validate()` fails, the first
172
 * component to fail validation will throw, so later components will not receive
173
 * a `validate()` call. `action()` on the composite will process the error,
174
 * which means `action()` on a component may be called before `validate()`.
175
 */
176
177
/**
178
 * Default action write an error to the log.
179
 */
180
class LogAction {
181
 public:
182
  LogAction() = default;
183
925
  inline void action(const Status& st) const {
184
925
    (void)LOG_STATUS(st);
185
925
  }
186
4.97M
  inline void action_on_success() {
187
4.97M
  }
188
4.97M
  inline void validate() {
189
4.97M
  }
190
};
191
192
/**
193
 * Exception class to report that a context is invalid.
194
 */
195
class InvalidContextException : public std::runtime_error {
196
 public:
197
  explicit InvalidContextException(std::string&& message)
198
18
      : std::runtime_error(message) {
199
18
  }
200
};
201
202
/**
203
 * Actions when `Context` is present in the API function.
204
 *
205
 * @invariant valid_ if and only if ctx_ is a pointer to a valid context handle
206
 */
207
class ContextAction {
208
  /**
209
   * Context argument as passed to the API function.
210
   */
211
  tiledb_ctx_handle_t* ctx_;
212
213
  /**
214
   * Validity of the context
215
   */
216
  bool valid_;
217
218
 public:
219
  /**
220
   * Constructor
221
   *
222
   * @param ctx An _unvalidated_ context pointer.
223
   */
224
  explicit ContextAction(tiledb_ctx_handle_t* ctx) noexcept
225
      : ctx_(ctx)
226
4.67M
      , valid_(is_handle_valid(ctx)) {
227
4.67M
  }
228
229
  /**
230
   * Report a validity failure by throwing.
231
   */
232
4.67M
  inline void validate() {
233
4.67M
    if (valid_) {
234
4.67M
      return;
235
4.67M
    }
236
    /*
237
     * This function with throw with an explanation in the exception.
238
     */
239
18
    ensure_context_is_valid<InvalidContextException>(ctx_);
240
18
  }
241
242
  /**
243
   * Action on exception
244
   */
245
836
  inline void action(const Status& st) {
246
836
    if (!valid_) {
247
      // Don't even try to report our own invalidity
248
17
      return;
249
17
    }
250
819
    tiledb::api::save_error(ctx_, st);
251
819
  }
252
253
  /**
254
   * Action on success.
255
   *
256
   * Success does not cause a context to clear its last error.
257
   */
258
4.67M
  inline void action_on_success() {
259
4.67M
  }
260
};
261
262
/**
263
 * Exception to report that an error action is invalid.
264
 */
265
class InvalidErrorException : public std::runtime_error {
266
 public:
267
  explicit InvalidErrorException(std::string&& message)
268
13
      : std::runtime_error(message) {
269
13
  }
270
};
271
272
/**
273
 * Actions when `Error` is present in the API function.
274
 *
275
 * @invariant valid_ if and only if err_ is a non-null pointer
276
 */
277
class ErrorAction {
278
  /**
279
   * Pointer to which an error handle might be written.
280
   */
281
  tiledb_error_handle_t** err_;
282
283
  /**
284
   * This action is valid if the error pointer is not null.
285
   */
286
  bool valid_;
287
288
 public:
289
  /**
290
   * Constructor
291
   *
292
   * @param err An _unvalidated_ error pointer.
293
   */
294
  explicit ErrorAction(tiledb_error_handle_t** err) noexcept
295
      : err_(err)
296
40.1k
      , valid_(err != nullptr) {
297
40.1k
  }
298
299
  /**
300
   * Validation reports that this object was constructed with a null pointer
301
   * argument.
302
   */
303
40.1k
  inline void validate() const {
304
40.1k
    if (!valid_) {
305
13
      throw InvalidErrorException("Error argument may not be a null pointer");
306
13
    }
307
40.1k
  }
308
309
  /**
310
   * Action to report an error
311
   */
312
57
  inline void action(const Status& st) {
313
57
    if (!valid_) {
314
12
      return;
315
12
    }
316
45
    tiledb::api::create_error(err_, st);
317
45
  }
318
319
  /**
320
   * Action if there is no error
321
   */
322
40.0k
  inline void action_on_success() {
323
    /*
324
     * No need to check validity here. `validate()` must have returned in order
325
     * for this function to run.
326
     */
327
40.0k
    *err_ = nullptr;
328
40.0k
  }
329
};
330
331
/**
332
 * Composite action that only logs.
333
 */
334
class ExceptionActionDetail : public ExceptionActionImpl<LogAction> {
335
 public:
336
  ExceptionActionDetail()
337
262k
      : ExceptionActionImpl<LogAction>{LogAction{}} {
338
262k
  }
339
};
340
341
/**
342
 * Composite action that logs and reports an error to a context
343
 */
344
class ExceptionActionDetailCtx
345
    : public ExceptionActionImpl<LogAction, ContextAction> {
346
 public:
347
  explicit ExceptionActionDetailCtx(tiledb_ctx_handle_t* ctx)
348
      : ExceptionActionImpl<LogAction, ContextAction>{LogAction{},
349
4.67M
                                                      ContextAction{ctx}} {
350
4.67M
  }
351
};
352
353
/**
354
 * Composite action that logs and reports an error through a new error handle.
355
 */
356
class ExceptionActionDetailErr
357
    : public ExceptionActionImpl<LogAction, ErrorAction> {
358
 public:
359
  explicit ExceptionActionDetailErr(tiledb_error_handle_t** err)
360
      : ExceptionActionImpl<LogAction, ErrorAction>{LogAction{},
361
40.1k
                                                    ErrorAction{err}} {
362
40.1k
  }
363
};
364
365
/**
366
 * Composite action that logs and reports an error to both a context and through
367
 * a new error handle.
368
 *
369
 * We don't have any API functions that require this at the present time, but
370
 * this class is used in testing to validate that chained action objects work
371
 * correctly in all circumstances.
372
 */
373
class ExceptionActionDetailCtxErr
374
    : public ExceptionActionImpl<LogAction, ContextAction, ErrorAction> {
375
 public:
376
  ExceptionActionDetailCtxErr(
377
      tiledb_ctx_handle_t* ctx, tiledb_error_handle_t** err)
378
      : ExceptionActionImpl<LogAction, ContextAction, ErrorAction>{
379
5
            LogAction{}, ContextAction{ctx}, ErrorAction{err}} {
380
5
  }
381
};
382
383
}  // namespace detail
384
385
using ExceptionAction = detail::ExceptionActionDetail;
386
using ExceptionActionCtx = detail::ExceptionActionDetailCtx;
387
using ExceptionActionErr = detail::ExceptionActionDetailErr;
388
using ExceptionActionCtxErr = detail::ExceptionActionDetailCtxErr;
389
390
/**
391
 * Non-specialized wrapper for implementations functions for the C API. May
392
 * only be used as a specialization.
393
 */
394
template <auto f, class H>
395
class CAPIFunction;
396
397
/**
398
 * Wrapper for implementations functions for the C API
399
 */
400
template <class... Args, capi_return_t (*f)(Args...), class H>
401
class CAPIFunction<f, H> {
402
  /**
403
   * Convert `std:bad_alloc` to a C API `Status`.
404
   */
405
0
  static inline Status exception_to_status(const std::bad_alloc& e) {
406
0
    return CAPIStatusError(
407
0
        std::string{"Out of memory, caught std::bad_alloc; "} + e.what());
408
0
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_type_to_str(tiledb_array_type_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_type_from_str(char const*, tiledb_array_type_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_layout_to_str(tiledb_layout_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_layout_from_str(char const*, tiledb_layout_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_encryption_type_to_str(tiledb_encryption_type_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_encryption_type_from_str(char const*, tiledb_encryption_type_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_status_to_str(tiledb_query_status_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_status_from_str(char const*, tiledb_query_status_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialization_type_to_str(tiledb_serialization_type_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialization_type_from_str(char const*, tiledb_serialization_type_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_mode_to_str(tiledb_vfs_mode_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_mode_from_str(char const*, tiledb_vfs_mode_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_list_alloc(tiledb_ctx_handle_t*, tiledb_buffer_list_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_buffer_list_free(tiledb_buffer_list_t**))>::function_from_void(tiledb_buffer_list_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_list_get_num_buffers(tiledb_ctx_handle_t*, tiledb_buffer_list_t const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_list_get_buffer(tiledb_ctx_handle_t*, tiledb_buffer_list_t const*, unsigned long long, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_list_get_total_size(tiledb_ctx_handle_t*, tiledb_buffer_list_t const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_list_flatten(tiledb_ctx_handle_t*, tiledb_buffer_list_t const*, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_alloc(tiledb_ctx_handle_t*, char const*, tiledb_datatype_t, tiledb_attribute_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_attribute_free(tiledb_attribute_t**))>::function_from_void(tiledb_attribute_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_set_nullable(tiledb_ctx_handle_t*, tiledb_attribute_t*, unsigned char)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_set_filter_list(tiledb_ctx_handle_t*, tiledb_attribute_t*, tiledb_filter_list_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_set_cell_val_num(tiledb_ctx_handle_t*, tiledb_attribute_t*, unsigned int)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_get_name(tiledb_ctx_handle_t*, tiledb_attribute_t const*, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_get_type(tiledb_ctx_handle_t*, tiledb_attribute_t const*, tiledb_datatype_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_get_nullable(tiledb_ctx_handle_t*, tiledb_attribute_t*, unsigned char*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_get_filter_list(tiledb_ctx_handle_t*, tiledb_attribute_t*, tiledb_filter_list_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_get_cell_val_num(tiledb_ctx_handle_t*, tiledb_attribute_t const*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_get_cell_size(tiledb_ctx_handle_t*, tiledb_attribute_t const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_dump(tiledb_ctx_handle_t*, tiledb_attribute_t const*, __sFILE*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_set_fill_value(tiledb_ctx_handle_t*, tiledb_attribute_t*, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_get_fill_value(tiledb_ctx_handle_t*, tiledb_attribute_t*, void const**, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_set_fill_value_nullable(tiledb_ctx_handle_t*, tiledb_attribute_t*, void const*, unsigned long long, unsigned char)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_get_fill_value_nullable(tiledb_ctx_handle_t*, tiledb_attribute_t*, void const**, unsigned long long*, unsigned char*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_domain_alloc(tiledb_ctx_handle_t*, tiledb_domain_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_domain_free(tiledb_domain_t**))>::function_from_void(tiledb_domain_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_domain_get_type(tiledb_ctx_handle_t*, tiledb_domain_t const*, tiledb_datatype_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_domain_get_ndim(tiledb_ctx_handle_t*, tiledb_domain_t const*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_domain_add_dimension(tiledb_ctx_handle_t*, tiledb_domain_t*, tiledb_dimension_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_domain_dump(tiledb_ctx_handle_t*, tiledb_domain_t const*, __sFILE*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_alloc(tiledb_ctx_handle_t*, char const*, tiledb_datatype_t, void const*, void const*, tiledb_dimension_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_dimension_free(tiledb_dimension_t**))>::function_from_void(tiledb_dimension_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_set_filter_list(tiledb_ctx_handle_t*, tiledb_dimension_t*, tiledb_filter_list_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_set_cell_val_num(tiledb_ctx_handle_t*, tiledb_dimension_t*, unsigned int)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_get_filter_list(tiledb_ctx_handle_t*, tiledb_dimension_t*, tiledb_filter_list_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_get_cell_val_num(tiledb_ctx_handle_t*, tiledb_dimension_t const*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_get_name(tiledb_ctx_handle_t*, tiledb_dimension_t const*, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_get_type(tiledb_ctx_handle_t*, tiledb_dimension_t const*, tiledb_datatype_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_get_domain(tiledb_ctx_handle_t*, tiledb_dimension_t const*, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_get_tile_extent(tiledb_ctx_handle_t*, tiledb_dimension_t const*, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_dump(tiledb_ctx_handle_t*, tiledb_dimension_t const*, __sFILE*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_domain_get_dimension_from_index(tiledb_ctx_handle_t*, tiledb_domain_t const*, unsigned int, tiledb_dimension_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_domain_get_dimension_from_name(tiledb_ctx_handle_t*, tiledb_domain_t const*, char const*, tiledb_dimension_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_domain_has_dimension(tiledb_ctx_handle_t*, tiledb_domain_t const*, char const*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_alloc(tiledb_ctx_handle_t*, tiledb_array_type_t, tiledb_array_schema_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_array_schema_free(tiledb_array_schema_t**))>::function_from_void(tiledb_array_schema_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_add_attribute(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_attribute_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_set_allows_dups(tiledb_ctx_handle_t*, tiledb_array_schema_t*, int)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_allows_dups(tiledb_ctx_handle_t*, tiledb_array_schema_t*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_version(tiledb_ctx_handle_t*, tiledb_array_schema_t*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_set_domain(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_domain_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_set_capacity(tiledb_ctx_handle_t*, tiledb_array_schema_t*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_set_cell_order(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_layout_t)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_set_tile_order(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_layout_t)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_timestamp_range(tiledb_ctx_handle_t*, tiledb_array_schema_t*, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_set_coords_filter_list(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_set_offsets_filter_list(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_set_validity_filter_list(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_check(tiledb_ctx_handle_t*, tiledb_array_schema_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_load(tiledb_ctx_handle_t*, char const*, tiledb_array_schema_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_load_with_key(tiledb_ctx_handle_t*, char const*, tiledb_encryption_type_t, void const*, unsigned int, tiledb_array_schema_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_array_type(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_array_type_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_capacity(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_cell_order(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_layout_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_coords_filter_list(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_offsets_filter_list(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_validity_filter_list(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_domain(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_domain_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_tile_order(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_layout_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_attribute_num(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_dump(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, __sFILE*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_attribute_from_index(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, unsigned int, tiledb_attribute_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_attribute_from_name(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, char const*, tiledb_attribute_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_has_attribute(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, char const*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_evolution_alloc(tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_array_schema_evolution_free(tiledb_array_schema_evolution_t**))>::function_from_void(tiledb_array_schema_evolution_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_evolution_add_attribute(tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t*, tiledb_attribute_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_evolution_drop_attribute(tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_evolution_set_timestamp_range(tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t*, unsigned long long, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_alloc(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t, tiledb_query_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_stats(tiledb_ctx_handle_t*, tiledb_query_t*, char**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_config(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_config(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_subarray(tiledb_ctx_handle_t*, tiledb_query_t*, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_subarray_t(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_subarray_t const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_buffer_var(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long*, unsigned long long*, void*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_buffer_nullable(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void*, unsigned long long*, unsigned char*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_buffer_var_nullable(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long*, unsigned long long*, void*, unsigned long long*, unsigned char*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_data_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_offsets_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_validity_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned char*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void**, unsigned long long**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_buffer_var(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long**, unsigned long long**, void**, unsigned long long**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_buffer_nullable(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void**, unsigned long long**, unsigned char**, unsigned long long**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_buffer_var_nullable(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long**, unsigned long long**, void**, unsigned long long**, unsigned char**, unsigned long long**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_data_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void**, unsigned long long**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_offsets_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long**, unsigned long long**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_validity_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned char**, unsigned long long**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_layout(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_layout_t)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_condition(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_query_condition_t const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_finalize(tiledb_ctx_handle_t*, tiledb_query_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_submit_and_finalize(tiledb_ctx_handle_t*, tiledb_query_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_query_free(tiledb_query_t**))>::function_from_void(tiledb_query_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_submit(tiledb_ctx_handle_t*, tiledb_query_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_submit_async(tiledb_ctx_handle_t*, tiledb_query_t*, void (*)(void*), void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_has_results(tiledb_ctx_handle_t*, tiledb_query_t*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_status(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_query_status_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_type(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_query_type_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_layout(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_layout_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_array(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_array_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_add_range(tiledb_ctx_handle_t*, tiledb_query_t*, unsigned int, void const*, void const*, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_add_point_ranges(tiledb_ctx_handle_t*, tiledb_query_t*, unsigned int, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_add_range_by_name(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void const*, void const*, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_add_range_var(tiledb_ctx_handle_t*, tiledb_query_t*, unsigned int, void const*, unsigned long long, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_add_range_var_by_name(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void const*, unsigned long long, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_range_num(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_range_num_from_name(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_range(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int, unsigned long long, void const**, void const**, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_range_from_name(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long, void const**, void const**, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_range_var_size(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int, unsigned long long, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_range_var_size_from_name(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_range_var(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int, unsigned long long, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_range_var_from_name(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_est_result_size(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_est_result_size_var(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_est_result_size_nullable(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_est_result_size_var_nullable(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_fragment_num(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_fragment_uri(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned long long, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_fragment_timestamp_range(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned long long, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_subarray_t(tiledb_ctx_handle_t*, tiledb_query_t const*, tiledb_subarray_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_relevant_fragment_num(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_alloc(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_subarray_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_set_config(tiledb_ctx_handle_t*, tiledb_subarray_t*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_subarray_free(tiledb_subarray_t**))>::function_from_void(tiledb_subarray_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_set_coalesce_ranges(tiledb_ctx_handle_t*, tiledb_subarray_t*, int)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_set_subarray(tiledb_ctx_handle_t*, tiledb_subarray_t*, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_add_range(tiledb_ctx_handle_t*, tiledb_subarray_t*, unsigned int, void const*, void const*, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_add_point_ranges(tiledb_ctx_handle_t*, tiledb_subarray_t*, unsigned int, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_add_range_by_name(tiledb_ctx_handle_t*, tiledb_subarray_t*, char const*, void const*, void const*, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_add_range_var(tiledb_ctx_handle_t*, tiledb_subarray_t*, unsigned int, void const*, unsigned long long, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_add_range_var_by_name(tiledb_ctx_handle_t*, tiledb_subarray_t*, char const*, void const*, unsigned long long, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_get_range_num(tiledb_ctx_handle_t*, tiledb_subarray_t const*, unsigned int, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_get_range_num_from_name(tiledb_ctx_handle_t*, tiledb_subarray_t const*, char const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_get_range(tiledb_ctx_handle_t*, tiledb_subarray_t const*, unsigned int, unsigned long long, void const**, void const**, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_get_range_var_size(tiledb_ctx_handle_t*, tiledb_subarray_t const*, unsigned int, unsigned long long, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_get_range_from_name(tiledb_ctx_handle_t*, tiledb_subarray_t const*, char const*, unsigned long long, void const**, void const**, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_get_range_var_size_from_name(tiledb_ctx_handle_t*, tiledb_subarray_t const*, char const*, unsigned long long, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_get_range_var(tiledb_ctx_handle_t*, tiledb_subarray_t const*, unsigned int, unsigned long long, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_get_range_var_from_name(tiledb_ctx_handle_t*, tiledb_subarray_t const*, char const*, unsigned long long, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_condition_alloc(tiledb_ctx_handle_t*, tiledb_query_condition_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_query_condition_free(tiledb_query_condition_t**))>::function_from_void(tiledb_query_condition_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_condition_init(tiledb_ctx_handle_t*, tiledb_query_condition_t*, char const*, void const*, unsigned long long, tiledb_query_condition_op_t)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_condition_combine(tiledb_ctx_handle_t*, tiledb_query_condition_t const*, tiledb_query_condition_t const*, tiledb_query_condition_combination_op_t, tiledb_query_condition_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_add_update_value(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_alloc(tiledb_ctx_handle_t*, char const*, tiledb_array_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_set_open_timestamp_start(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_set_open_timestamp_end(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_open_timestamp_start(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_open_timestamp_end(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_delete_array(tiledb_ctx_handle_t*, tiledb_array_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_delete_fragments(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, unsigned long long, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_open(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_open_at(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_open_with_key(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t, tiledb_encryption_type_t, void const*, unsigned int)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_open_at_with_key(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t, tiledb_encryption_type_t, void const*, unsigned int, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_is_open(tiledb_ctx_handle_t*, tiledb_array_t*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_reopen(tiledb_ctx_handle_t*, tiledb_array_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_reopen_at(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_timestamp(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_set_config(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_config(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_close(tiledb_ctx_handle_t*, tiledb_array_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_array_free(tiledb_array_t**))>::function_from_void(tiledb_array_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_schema(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_array_schema_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_query_type(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_create(tiledb_ctx_handle_t*, char const*, tiledb_array_schema_t const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_create_with_key(tiledb_ctx_handle_t*, char const*, tiledb_array_schema_t const*, tiledb_encryption_type_t, void const*, unsigned int)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_consolidate(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_consolidate_with_key(tiledb_ctx_handle_t*, char const*, tiledb_encryption_type_t, void const*, unsigned int, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_consolidate_fragments(tiledb_ctx_handle_t*, char const*, char const**, unsigned long long, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_vacuum(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_non_empty_domain(tiledb_ctx_handle_t*, tiledb_array_t*, void*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_non_empty_domain_from_index(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned int, void*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_non_empty_domain_from_name(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, void*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_non_empty_domain_var_size_from_index(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned int, unsigned long long*, unsigned long long*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_non_empty_domain_var_size_from_name(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, unsigned long long*, unsigned long long*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_non_empty_domain_var_from_index(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned int, void*, void*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_non_empty_domain_var_from_name(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, void*, void*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_uri(tiledb_ctx_handle_t*, tiledb_array_t*, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_encryption_type(tiledb_ctx_handle_t*, char const*, tiledb_encryption_type_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_put_metadata(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, tiledb_datatype_t, unsigned int, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_delete_metadata(tiledb_ctx_handle_t*, tiledb_array_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_metadata(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, tiledb_datatype_t*, unsigned int*, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_metadata_num(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_metadata_from_index(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long, char const**, unsigned int*, tiledb_datatype_t*, unsigned int*, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_has_metadata_key(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, tiledb_datatype_t*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_consolidate_metadata(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_consolidate_metadata_with_key(tiledb_ctx_handle_t*, char const*, tiledb_encryption_type_t, void const*, unsigned int, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_evolve(tiledb_ctx_handle_t*, char const*, tiledb_array_schema_evolution_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_upgrade_version(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_object_type(tiledb_ctx_handle_t*, char const*, tiledb_object_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_object_remove(tiledb_ctx_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_object_move(tiledb_ctx_handle_t*, char const*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_object_walk(tiledb_ctx_handle_t*, char const*, tiledb_walk_order_t, int (*)(char const*, tiledb_object_t, void*), void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_object_ls(tiledb_ctx_handle_t*, char const*, int (*)(char const*, tiledb_object_t, void*), void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_alloc(tiledb_ctx_handle_t*, tiledb_config_handle_t*, tiledb_vfs_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_vfs_free(tiledb_vfs_t**))>::function_from_void(tiledb_vfs_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_get_config(tiledb_ctx_handle_t*, tiledb_vfs_t*, tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_create_bucket(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_remove_bucket(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_empty_bucket(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_is_empty_bucket(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_is_bucket(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_create_dir(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_is_dir(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_remove_dir(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_is_file(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_remove_file(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_dir_size(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_file_size(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_move_file(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_move_dir(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_copy_file(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_copy_dir(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_open(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, tiledb_vfs_mode_t, tiledb_vfs_fh_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_close(tiledb_ctx_handle_t*, tiledb_vfs_fh_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_read(tiledb_ctx_handle_t*, tiledb_vfs_fh_t*, unsigned long long, void*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_write(tiledb_ctx_handle_t*, tiledb_vfs_fh_t*, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_sync(tiledb_ctx_handle_t*, tiledb_vfs_fh_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_ls(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int (*)(char const*, void*), void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_vfs_fh_free(tiledb_vfs_fh_t**))>::function_from_void(tiledb_vfs_fh_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_fh_is_closed(tiledb_ctx_handle_t*, tiledb_vfs_fh_t*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_touch(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_uri_to_path(tiledb_ctx_handle_t*, char const*, char*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_enable()), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_disable()), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_reset()), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_dump(__sFILE*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_dump_str(char**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_raw_dump(__sFILE*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_raw_dump_str(char**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_free_str(char**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_heap_profiler_enable(char const*, unsigned long long, unsigned long long, unsigned long long)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_array(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_array(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_array_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_array_schema(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_array_schema(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_array_schema_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_array_open(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_array_open(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_array_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_array_schema_evolution(tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_array_schema_evolution(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_array_schema_evolution_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_query(tiledb_ctx_handle_t*, tiledb_query_t const*, tiledb_serialization_type_t, int, tiledb_buffer_list_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_query(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_query_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_array_nonempty_domain(tiledb_ctx_handle_t*, tiledb_array_t const*, void const*, int, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_array_nonempty_domain(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, void*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_array_non_empty_domain_all_dimensions(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_array_non_empty_domain_all_dimensions(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_array_max_buffer_sizes(tiledb_ctx_handle_t*, tiledb_array_t const*, void const*, tiledb_serialization_type_t, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_array_metadata(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_serialization_type_t, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_array_metadata(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_serialization_type_t, tiledb_buffer_handle_t const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_query_est_result_sizes(tiledb_ctx_handle_t*, tiledb_query_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_query_est_result_sizes(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_config(tiledb_ctx_handle_t*, tiledb_config_handle_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_config(tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_fragment_info_request(tiledb_ctx_handle_t*, tiledb_fragment_info_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_fragment_info_request(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_fragment_info_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_fragment_info(tiledb_ctx_handle_t*, tiledb_fragment_info_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_fragment_info(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, char const*, int, tiledb_fragment_info_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::impl::tiledb_query_submit_async_func(tiledb_ctx_handle_t*, tiledb_query_t*, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_alloc(tiledb_ctx_handle_t*, char const*, tiledb_fragment_info_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_fragment_info_free(tiledb_fragment_info_t**))>::function_from_void(tiledb_fragment_info_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_set_config(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_config(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_load(tiledb_ctx_handle_t*, tiledb_fragment_info_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_load_with_key(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, tiledb_encryption_type_t, void const*, unsigned int)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_fragment_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_fragment_num(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_fragment_uri(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_fragment_size(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_dense(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_sparse(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_timestamp_range(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_non_empty_domain_from_index(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_non_empty_domain_from_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_non_empty_domain_var_size_from_index(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_non_empty_domain_var_size_from_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const*, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_non_empty_domain_var_from_index(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_non_empty_domain_var_from_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const*, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_mbr_num(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_mbr_from_index(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, unsigned int, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_mbr_from_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, char const*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_mbr_var_size_from_index(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, unsigned int, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_mbr_var_size_from_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, char const*, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_mbr_var_from_index(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, unsigned int, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_mbr_var_from_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, char const*, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_cell_num(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_total_cell_num(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_version(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_has_consolidated_metadata(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_unconsolidated_metadata_num(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_to_vacuum_num(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_to_vacuum_uri(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_array_schema(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, tiledb_array_schema_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_array_schema_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_dump(tiledb_ctx_handle_t*, tiledb_fragment_info_t const*, __sFILE*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_status_details(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_experimental_query_status_details_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_consolidation_plan_create_with_mbr(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long, tiledb_consolidation_plan_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_consolidation_plan_free(tiledb_consolidation_plan_t**))>::function_from_void(tiledb_consolidation_plan_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_consolidation_plan_get_num_nodes(tiledb_ctx_handle_t*, tiledb_consolidation_plan_t*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_consolidation_plan_get_num_fragments(tiledb_ctx_handle_t*, tiledb_consolidation_plan_t*, unsigned long long, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_consolidation_plan_get_fragment_uri(tiledb_ctx_handle_t*, tiledb_consolidation_plan_t*, unsigned long long, unsigned long long, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_consolidation_plan_dump_json_str(tiledb_ctx_handle_t*, tiledb_consolidation_plan_t const*, char**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_consolidation_plan_free_json_str(char**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::common::detail::tiledb_filestore_schema_create(tiledb_ctx_handle_t*, char const*, tiledb_array_schema_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::common::detail::tiledb_filestore_uri_import(tiledb_ctx_handle_t*, char const*, char const*, tiledb_mime_type_t)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::common::detail::tiledb_filestore_uri_export(tiledb_ctx_handle_t*, char const*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::common::detail::tiledb_filestore_buffer_import(tiledb_ctx_handle_t*, char const*, void*, unsigned long, tiledb_mime_type_t)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::common::detail::tiledb_filestore_buffer_export(tiledb_ctx_handle_t*, char const*, unsigned long, void*, unsigned long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::common::detail::tiledb_filestore_size(tiledb_ctx_handle_t*, char const*, unsigned long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::common::detail::tiledb_mime_type_to_str(tiledb_mime_type_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::common::detail::tiledb_mime_type_from_str(char const*, tiledb_mime_type_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_alloc(tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_buffer_free(tiledb_buffer_handle_t**))>::function_from_void(tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_set_type(tiledb_buffer_handle_t*, tiledb_datatype_t)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_get_type(tiledb_buffer_handle_t const*, tiledb_datatype_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_get_data(tiledb_buffer_handle_t const*, void**, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_set_data(tiledb_buffer_handle_t*, void*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_error_message(tiledb_error_handle_t*, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_error_free(tiledb_error_handle_t**))>::function_from_void(tiledb_error_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_alloc(tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_config_free(tiledb_config_handle_t**))>::function_from_void(tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_set(tiledb_config_handle_t*, char const*, char const*)), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_get(tiledb_config_handle_t*, char const*, char const**)), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_unset(tiledb_config_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_load_from_file(tiledb_config_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_save_to_file(tiledb_config_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_compare(tiledb_config_handle_t*, tiledb_config_handle_t*, unsigned char*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_iter_alloc(tiledb_config_handle_t*, char const*, tiledb_config_iter_handle_t**)), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_iter_reset(tiledb_config_handle_t*, tiledb_config_iter_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_config_iter_free(tiledb_config_iter_handle_t**))>::function_from_void(tiledb_config_iter_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_iter_here(tiledb_config_iter_handle_t*, char const**, char const**)), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_iter_next(tiledb_config_iter_handle_t*)), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_iter_done(tiledb_config_iter_handle_t*, int*)), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_ctx_alloc(tiledb_config_handle_t*, tiledb_ctx_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_ctx_alloc(tiledb_config_handle_t*, tiledb_ctx_handle_t**)), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_ctx_free(tiledb_ctx_handle_t**))>::function_from_void(tiledb_ctx_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_ctx_get_stats(tiledb_ctx_handle_t*, char**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_ctx_get_config(tiledb_ctx_handle_t*, tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_ctx_get_last_error(tiledb_ctx_handle_t*, tiledb_error_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_ctx_is_supported_fs(tiledb_ctx_handle_t*, tiledb_filesystem_t, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_ctx_cancel_tasks(tiledb_ctx_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_ctx_set_tag(tiledb_ctx_handle_t*, char const*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_datatype_to_str(tiledb_datatype_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_datatype_from_str(char const*, tiledb_datatype_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filesystem_to_str(tiledb_filesystem_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filesystem_from_str(char const*, tiledb_filesystem_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_alloc(tiledb_ctx_handle_t*, tiledb_filter_type_t, tiledb_filter_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_filter_free(tiledb_filter_handle_t**))>::function_from_void(tiledb_filter_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_get_type(tiledb_filter_handle_t*, tiledb_filter_type_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_set_option(tiledb_filter_handle_t*, tiledb_filter_option_t, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_get_option(tiledb_filter_handle_t*, tiledb_filter_option_t, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_type_to_str(tiledb_filter_type_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_type_from_str(char const*, tiledb_filter_type_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_option_to_str(tiledb_filter_option_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_option_from_str(char const*, tiledb_filter_option_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_list_alloc(tiledb_ctx_handle_t*, tiledb_filter_list_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_filter_list_free(tiledb_filter_list_handle_t**))>::function_from_void(tiledb_filter_list_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_list_add_filter(tiledb_filter_list_handle_t*, tiledb_filter_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_list_set_max_chunk_size(tiledb_filter_list_handle_t*, unsigned int)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_list_get_nfilters(tiledb_filter_list_handle_t const*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_list_get_filter_from_index(tiledb_filter_list_handle_t const*, unsigned int, tiledb_filter_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_list_get_max_chunk_size(tiledb_filter_list_handle_t const*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_create(tiledb_ctx_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_alloc(tiledb_ctx_handle_t*, char const*, tiledb_group_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_open(tiledb_group_handle_t*, tiledb_query_type_t)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_close(tiledb_group_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_group_free(tiledb_group_handle_t**))>::function_from_void(tiledb_group_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_set_config(tiledb_group_handle_t*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_config(tiledb_group_handle_t*, tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_put_metadata(tiledb_group_handle_t*, char const*, tiledb_datatype_t, unsigned int, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_delete_group(tiledb_group_handle_t*, char const*, unsigned char)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_delete_metadata(tiledb_group_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_metadata(tiledb_group_handle_t*, char const*, tiledb_datatype_t*, unsigned int*, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_metadata_num(tiledb_group_handle_t*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_metadata_from_index(tiledb_group_handle_t*, unsigned long long, char const**, unsigned int*, tiledb_datatype_t*, unsigned int*, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_has_metadata_key(tiledb_group_handle_t*, char const*, tiledb_datatype_t*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_add_member(tiledb_group_handle_t*, char const*, unsigned char, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_remove_member(tiledb_group_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_member_count(tiledb_group_handle_t*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_member_by_index(tiledb_group_handle_t*, unsigned long long, char**, tiledb_object_t*, char**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_member_by_name(tiledb_group_handle_t*, char const*, char**, tiledb_object_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_is_relative_uri_by_name(tiledb_group_handle_t*, char const*, unsigned char*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_is_open(tiledb_group_handle_t*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_uri(tiledb_group_handle_t*, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_query_type(tiledb_group_handle_t*, tiledb_query_type_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_dump_str(tiledb_group_handle_t*, char**, unsigned char)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_group(tiledb_group_handle_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_group(tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_group_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_group_metadata(tiledb_group_handle_t const*, tiledb_serialization_type_t, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_group_metadata(tiledb_group_handle_t*, tiledb_serialization_type_t, tiledb_buffer_handle_t const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_consolidate_metadata(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_vacuum_metadata(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_object_type_to_str(tiledb_object_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_object_type_from_str(char const*, tiledb_object_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_walk_order_to_str(tiledb_walk_order_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_walk_order_from_str(char const*, tiledb_walk_order_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_type_to_str(tiledb_query_type_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_type_from_str(char const*, tiledb_query_type_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tf_always_good()), tiledb::api::detail::ExceptionActionDetailCtxErr>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tf_always_throw()), tiledb::api::detail::ExceptionActionDetailCtxErr>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tf_assign(int, int*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tf_always_throw()), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tf_void_assign(int, int*))>::function_from_void(int, int*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tf_void_throw())>::function_from_void()), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tf_context_assign(tiledb_ctx_handle_t*, int, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tf_context_throw(tiledb_ctx_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tf_assign(int, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tf_always_throw()), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tf_assign(int, int*)), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::bad_alloc const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tf_always_throw()), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::bad_alloc const&)
409
410
  /**
411
   * Convert `std:exception` to a C API `Status`.
412
   */
413
55
  static inline Status exception_to_status(const std::exception& e) {
414
55
    return CAPIStatusError(
415
55
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
55
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_type_to_str(tiledb_array_type_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_type_from_str(char const*, tiledb_array_type_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_layout_to_str(tiledb_layout_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_layout_from_str(char const*, tiledb_layout_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_encryption_type_to_str(tiledb_encryption_type_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_encryption_type_from_str(char const*, tiledb_encryption_type_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_status_to_str(tiledb_query_status_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_status_from_str(char const*, tiledb_query_status_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialization_type_to_str(tiledb_serialization_type_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialization_type_from_str(char const*, tiledb_serialization_type_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_mode_to_str(tiledb_vfs_mode_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_mode_from_str(char const*, tiledb_vfs_mode_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_list_alloc(tiledb_ctx_handle_t*, tiledb_buffer_list_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_buffer_list_free(tiledb_buffer_list_t**))>::function_from_void(tiledb_buffer_list_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_list_get_num_buffers(tiledb_ctx_handle_t*, tiledb_buffer_list_t const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_list_get_buffer(tiledb_ctx_handle_t*, tiledb_buffer_list_t const*, unsigned long long, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_list_get_total_size(tiledb_ctx_handle_t*, tiledb_buffer_list_t const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_list_flatten(tiledb_ctx_handle_t*, tiledb_buffer_list_t const*, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_alloc(tiledb_ctx_handle_t*, char const*, tiledb_datatype_t, tiledb_attribute_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_attribute_free(tiledb_attribute_t**))>::function_from_void(tiledb_attribute_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_set_nullable(tiledb_ctx_handle_t*, tiledb_attribute_t*, unsigned char)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_set_filter_list(tiledb_ctx_handle_t*, tiledb_attribute_t*, tiledb_filter_list_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_set_cell_val_num(tiledb_ctx_handle_t*, tiledb_attribute_t*, unsigned int)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_get_name(tiledb_ctx_handle_t*, tiledb_attribute_t const*, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_get_type(tiledb_ctx_handle_t*, tiledb_attribute_t const*, tiledb_datatype_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_get_nullable(tiledb_ctx_handle_t*, tiledb_attribute_t*, unsigned char*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_get_filter_list(tiledb_ctx_handle_t*, tiledb_attribute_t*, tiledb_filter_list_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_get_cell_val_num(tiledb_ctx_handle_t*, tiledb_attribute_t const*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_get_cell_size(tiledb_ctx_handle_t*, tiledb_attribute_t const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_dump(tiledb_ctx_handle_t*, tiledb_attribute_t const*, __sFILE*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_set_fill_value(tiledb_ctx_handle_t*, tiledb_attribute_t*, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_get_fill_value(tiledb_ctx_handle_t*, tiledb_attribute_t*, void const**, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_set_fill_value_nullable(tiledb_ctx_handle_t*, tiledb_attribute_t*, void const*, unsigned long long, unsigned char)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_get_fill_value_nullable(tiledb_ctx_handle_t*, tiledb_attribute_t*, void const**, unsigned long long*, unsigned char*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_domain_alloc(tiledb_ctx_handle_t*, tiledb_domain_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_domain_free(tiledb_domain_t**))>::function_from_void(tiledb_domain_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_domain_get_type(tiledb_ctx_handle_t*, tiledb_domain_t const*, tiledb_datatype_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_domain_get_ndim(tiledb_ctx_handle_t*, tiledb_domain_t const*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_domain_add_dimension(tiledb_ctx_handle_t*, tiledb_domain_t*, tiledb_dimension_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_domain_dump(tiledb_ctx_handle_t*, tiledb_domain_t const*, __sFILE*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_alloc(tiledb_ctx_handle_t*, char const*, tiledb_datatype_t, void const*, void const*, tiledb_dimension_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Line
Count
Source
413
4
  static inline Status exception_to_status(const std::exception& e) {
414
4
    return CAPIStatusError(
415
4
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
4
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_dimension_free(tiledb_dimension_t**))>::function_from_void(tiledb_dimension_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_set_filter_list(tiledb_ctx_handle_t*, tiledb_dimension_t*, tiledb_filter_list_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_set_cell_val_num(tiledb_ctx_handle_t*, tiledb_dimension_t*, unsigned int)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_get_filter_list(tiledb_ctx_handle_t*, tiledb_dimension_t*, tiledb_filter_list_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_get_cell_val_num(tiledb_ctx_handle_t*, tiledb_dimension_t const*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_get_name(tiledb_ctx_handle_t*, tiledb_dimension_t const*, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_get_type(tiledb_ctx_handle_t*, tiledb_dimension_t const*, tiledb_datatype_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_get_domain(tiledb_ctx_handle_t*, tiledb_dimension_t const*, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_get_tile_extent(tiledb_ctx_handle_t*, tiledb_dimension_t const*, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_dump(tiledb_ctx_handle_t*, tiledb_dimension_t const*, __sFILE*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_domain_get_dimension_from_index(tiledb_ctx_handle_t*, tiledb_domain_t const*, unsigned int, tiledb_dimension_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_domain_get_dimension_from_name(tiledb_ctx_handle_t*, tiledb_domain_t const*, char const*, tiledb_dimension_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_domain_has_dimension(tiledb_ctx_handle_t*, tiledb_domain_t const*, char const*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_alloc(tiledb_ctx_handle_t*, tiledb_array_type_t, tiledb_array_schema_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_array_schema_free(tiledb_array_schema_t**))>::function_from_void(tiledb_array_schema_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_add_attribute(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_attribute_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_set_allows_dups(tiledb_ctx_handle_t*, tiledb_array_schema_t*, int)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_allows_dups(tiledb_ctx_handle_t*, tiledb_array_schema_t*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_version(tiledb_ctx_handle_t*, tiledb_array_schema_t*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_set_domain(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_domain_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_set_capacity(tiledb_ctx_handle_t*, tiledb_array_schema_t*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_set_cell_order(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_layout_t)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_set_tile_order(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_layout_t)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_timestamp_range(tiledb_ctx_handle_t*, tiledb_array_schema_t*, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_set_coords_filter_list(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_set_offsets_filter_list(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_set_validity_filter_list(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_check(tiledb_ctx_handle_t*, tiledb_array_schema_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_load(tiledb_ctx_handle_t*, char const*, tiledb_array_schema_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_load_with_key(tiledb_ctx_handle_t*, char const*, tiledb_encryption_type_t, void const*, unsigned int, tiledb_array_schema_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_array_type(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_array_type_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_capacity(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_cell_order(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_layout_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_coords_filter_list(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_offsets_filter_list(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_validity_filter_list(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_domain(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_domain_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_tile_order(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_layout_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_attribute_num(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_dump(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, __sFILE*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_attribute_from_index(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, unsigned int, tiledb_attribute_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_attribute_from_name(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, char const*, tiledb_attribute_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_has_attribute(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, char const*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_evolution_alloc(tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_array_schema_evolution_free(tiledb_array_schema_evolution_t**))>::function_from_void(tiledb_array_schema_evolution_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_evolution_add_attribute(tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t*, tiledb_attribute_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_evolution_drop_attribute(tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_evolution_set_timestamp_range(tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t*, unsigned long long, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_alloc(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t, tiledb_query_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_stats(tiledb_ctx_handle_t*, tiledb_query_t*, char**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_config(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_config(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_subarray(tiledb_ctx_handle_t*, tiledb_query_t*, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_subarray_t(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_subarray_t const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_buffer_var(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long*, unsigned long long*, void*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_buffer_nullable(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void*, unsigned long long*, unsigned char*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_buffer_var_nullable(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long*, unsigned long long*, void*, unsigned long long*, unsigned char*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_data_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_offsets_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_validity_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned char*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void**, unsigned long long**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_buffer_var(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long**, unsigned long long**, void**, unsigned long long**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_buffer_nullable(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void**, unsigned long long**, unsigned char**, unsigned long long**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_buffer_var_nullable(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long**, unsigned long long**, void**, unsigned long long**, unsigned char**, unsigned long long**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_data_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void**, unsigned long long**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_offsets_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long**, unsigned long long**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_validity_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned char**, unsigned long long**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_layout(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_layout_t)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_condition(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_query_condition_t const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_finalize(tiledb_ctx_handle_t*, tiledb_query_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Line
Count
Source
413
2
  static inline Status exception_to_status(const std::exception& e) {
414
2
    return CAPIStatusError(
415
2
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
2
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_submit_and_finalize(tiledb_ctx_handle_t*, tiledb_query_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_query_free(tiledb_query_t**))>::function_from_void(tiledb_query_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_submit(tiledb_ctx_handle_t*, tiledb_query_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_submit_async(tiledb_ctx_handle_t*, tiledb_query_t*, void (*)(void*), void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_has_results(tiledb_ctx_handle_t*, tiledb_query_t*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_status(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_query_status_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_type(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_query_type_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_layout(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_layout_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_array(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_array_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_add_range(tiledb_ctx_handle_t*, tiledb_query_t*, unsigned int, void const*, void const*, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_add_point_ranges(tiledb_ctx_handle_t*, tiledb_query_t*, unsigned int, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_add_range_by_name(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void const*, void const*, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_add_range_var(tiledb_ctx_handle_t*, tiledb_query_t*, unsigned int, void const*, unsigned long long, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_add_range_var_by_name(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void const*, unsigned long long, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_range_num(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_range_num_from_name(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_range(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int, unsigned long long, void const**, void const**, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_range_from_name(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long, void const**, void const**, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_range_var_size(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int, unsigned long long, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_range_var_size_from_name(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_range_var(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int, unsigned long long, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_range_var_from_name(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_est_result_size(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_est_result_size_var(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_est_result_size_nullable(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_est_result_size_var_nullable(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_fragment_num(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_fragment_uri(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned long long, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_fragment_timestamp_range(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned long long, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_subarray_t(tiledb_ctx_handle_t*, tiledb_query_t const*, tiledb_subarray_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_relevant_fragment_num(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_alloc(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_subarray_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_set_config(tiledb_ctx_handle_t*, tiledb_subarray_t*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_subarray_free(tiledb_subarray_t**))>::function_from_void(tiledb_subarray_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_set_coalesce_ranges(tiledb_ctx_handle_t*, tiledb_subarray_t*, int)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_set_subarray(tiledb_ctx_handle_t*, tiledb_subarray_t*, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_add_range(tiledb_ctx_handle_t*, tiledb_subarray_t*, unsigned int, void const*, void const*, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Line
Count
Source
413
5
  static inline Status exception_to_status(const std::exception& e) {
414
5
    return CAPIStatusError(
415
5
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
5
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_add_point_ranges(tiledb_ctx_handle_t*, tiledb_subarray_t*, unsigned int, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_add_range_by_name(tiledb_ctx_handle_t*, tiledb_subarray_t*, char const*, void const*, void const*, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_add_range_var(tiledb_ctx_handle_t*, tiledb_subarray_t*, unsigned int, void const*, unsigned long long, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_add_range_var_by_name(tiledb_ctx_handle_t*, tiledb_subarray_t*, char const*, void const*, unsigned long long, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_get_range_num(tiledb_ctx_handle_t*, tiledb_subarray_t const*, unsigned int, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_get_range_num_from_name(tiledb_ctx_handle_t*, tiledb_subarray_t const*, char const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_get_range(tiledb_ctx_handle_t*, tiledb_subarray_t const*, unsigned int, unsigned long long, void const**, void const**, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_get_range_var_size(tiledb_ctx_handle_t*, tiledb_subarray_t const*, unsigned int, unsigned long long, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_get_range_from_name(tiledb_ctx_handle_t*, tiledb_subarray_t const*, char const*, unsigned long long, void const**, void const**, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_get_range_var_size_from_name(tiledb_ctx_handle_t*, tiledb_subarray_t const*, char const*, unsigned long long, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_get_range_var(tiledb_ctx_handle_t*, tiledb_subarray_t const*, unsigned int, unsigned long long, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_get_range_var_from_name(tiledb_ctx_handle_t*, tiledb_subarray_t const*, char const*, unsigned long long, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_condition_alloc(tiledb_ctx_handle_t*, tiledb_query_condition_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_query_condition_free(tiledb_query_condition_t**))>::function_from_void(tiledb_query_condition_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_condition_init(tiledb_ctx_handle_t*, tiledb_query_condition_t*, char const*, void const*, unsigned long long, tiledb_query_condition_op_t)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_condition_combine(tiledb_ctx_handle_t*, tiledb_query_condition_t const*, tiledb_query_condition_t const*, tiledb_query_condition_combination_op_t, tiledb_query_condition_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_add_update_value(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_alloc(tiledb_ctx_handle_t*, char const*, tiledb_array_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_set_open_timestamp_start(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_set_open_timestamp_end(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_open_timestamp_start(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_open_timestamp_end(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_delete_array(tiledb_ctx_handle_t*, tiledb_array_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_delete_fragments(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, unsigned long long, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_open(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_open_at(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_open_with_key(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t, tiledb_encryption_type_t, void const*, unsigned int)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_open_at_with_key(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t, tiledb_encryption_type_t, void const*, unsigned int, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_is_open(tiledb_ctx_handle_t*, tiledb_array_t*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_reopen(tiledb_ctx_handle_t*, tiledb_array_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_reopen_at(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_timestamp(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_set_config(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_config(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_close(tiledb_ctx_handle_t*, tiledb_array_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_array_free(tiledb_array_t**))>::function_from_void(tiledb_array_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_schema(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_array_schema_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_query_type(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_create(tiledb_ctx_handle_t*, char const*, tiledb_array_schema_t const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_create_with_key(tiledb_ctx_handle_t*, char const*, tiledb_array_schema_t const*, tiledb_encryption_type_t, void const*, unsigned int)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_consolidate(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Line
Count
Source
413
5
  static inline Status exception_to_status(const std::exception& e) {
414
5
    return CAPIStatusError(
415
5
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
5
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_consolidate_with_key(tiledb_ctx_handle_t*, char const*, tiledb_encryption_type_t, void const*, unsigned int, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_consolidate_fragments(tiledb_ctx_handle_t*, char const*, char const**, unsigned long long, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_vacuum(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_non_empty_domain(tiledb_ctx_handle_t*, tiledb_array_t*, void*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_non_empty_domain_from_index(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned int, void*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_non_empty_domain_from_name(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, void*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_non_empty_domain_var_size_from_index(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned int, unsigned long long*, unsigned long long*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_non_empty_domain_var_size_from_name(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, unsigned long long*, unsigned long long*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_non_empty_domain_var_from_index(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned int, void*, void*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_non_empty_domain_var_from_name(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, void*, void*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_uri(tiledb_ctx_handle_t*, tiledb_array_t*, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_encryption_type(tiledb_ctx_handle_t*, char const*, tiledb_encryption_type_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_put_metadata(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, tiledb_datatype_t, unsigned int, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_delete_metadata(tiledb_ctx_handle_t*, tiledb_array_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_metadata(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, tiledb_datatype_t*, unsigned int*, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_metadata_num(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_metadata_from_index(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long, char const**, unsigned int*, tiledb_datatype_t*, unsigned int*, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_has_metadata_key(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, tiledb_datatype_t*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_consolidate_metadata(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_consolidate_metadata_with_key(tiledb_ctx_handle_t*, char const*, tiledb_encryption_type_t, void const*, unsigned int, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_evolve(tiledb_ctx_handle_t*, char const*, tiledb_array_schema_evolution_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_upgrade_version(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_object_type(tiledb_ctx_handle_t*, char const*, tiledb_object_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_object_remove(tiledb_ctx_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_object_move(tiledb_ctx_handle_t*, char const*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_object_walk(tiledb_ctx_handle_t*, char const*, tiledb_walk_order_t, int (*)(char const*, tiledb_object_t, void*), void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_object_ls(tiledb_ctx_handle_t*, char const*, int (*)(char const*, tiledb_object_t, void*), void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_alloc(tiledb_ctx_handle_t*, tiledb_config_handle_t*, tiledb_vfs_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_vfs_free(tiledb_vfs_t**))>::function_from_void(tiledb_vfs_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_get_config(tiledb_ctx_handle_t*, tiledb_vfs_t*, tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_create_bucket(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_remove_bucket(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_empty_bucket(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_is_empty_bucket(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_is_bucket(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_create_dir(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_is_dir(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_remove_dir(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_is_file(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_remove_file(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_dir_size(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_file_size(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_move_file(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_move_dir(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_copy_file(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_copy_dir(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_open(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, tiledb_vfs_mode_t, tiledb_vfs_fh_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_close(tiledb_ctx_handle_t*, tiledb_vfs_fh_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_read(tiledb_ctx_handle_t*, tiledb_vfs_fh_t*, unsigned long long, void*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_write(tiledb_ctx_handle_t*, tiledb_vfs_fh_t*, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_sync(tiledb_ctx_handle_t*, tiledb_vfs_fh_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_ls(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int (*)(char const*, void*), void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_vfs_fh_free(tiledb_vfs_fh_t**))>::function_from_void(tiledb_vfs_fh_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_fh_is_closed(tiledb_ctx_handle_t*, tiledb_vfs_fh_t*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_touch(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_uri_to_path(tiledb_ctx_handle_t*, char const*, char*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_enable()), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_disable()), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_reset()), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_dump(__sFILE*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_dump_str(char**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_raw_dump(__sFILE*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_raw_dump_str(char**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_free_str(char**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_heap_profiler_enable(char const*, unsigned long long, unsigned long long, unsigned long long)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_array(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_array(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_array_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_array_schema(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_array_schema(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_array_schema_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_array_open(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_array_open(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_array_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_array_schema_evolution(tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_array_schema_evolution(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_array_schema_evolution_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_query(tiledb_ctx_handle_t*, tiledb_query_t const*, tiledb_serialization_type_t, int, tiledb_buffer_list_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_query(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_query_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_array_nonempty_domain(tiledb_ctx_handle_t*, tiledb_array_t const*, void const*, int, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_array_nonempty_domain(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, void*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_array_non_empty_domain_all_dimensions(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_array_non_empty_domain_all_dimensions(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_array_max_buffer_sizes(tiledb_ctx_handle_t*, tiledb_array_t const*, void const*, tiledb_serialization_type_t, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_array_metadata(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_serialization_type_t, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_array_metadata(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_serialization_type_t, tiledb_buffer_handle_t const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_query_est_result_sizes(tiledb_ctx_handle_t*, tiledb_query_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_query_est_result_sizes(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_config(tiledb_ctx_handle_t*, tiledb_config_handle_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_config(tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_fragment_info_request(tiledb_ctx_handle_t*, tiledb_fragment_info_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_fragment_info_request(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_fragment_info_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_fragment_info(tiledb_ctx_handle_t*, tiledb_fragment_info_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_fragment_info(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, char const*, int, tiledb_fragment_info_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::impl::tiledb_query_submit_async_func(tiledb_ctx_handle_t*, tiledb_query_t*, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_alloc(tiledb_ctx_handle_t*, char const*, tiledb_fragment_info_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_fragment_info_free(tiledb_fragment_info_t**))>::function_from_void(tiledb_fragment_info_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_set_config(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_config(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_load(tiledb_ctx_handle_t*, tiledb_fragment_info_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Line
Count
Source
413
4
  static inline Status exception_to_status(const std::exception& e) {
414
4
    return CAPIStatusError(
415
4
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
4
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_load_with_key(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, tiledb_encryption_type_t, void const*, unsigned int)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_fragment_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_fragment_num(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_fragment_uri(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_fragment_size(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_dense(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_sparse(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_timestamp_range(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_non_empty_domain_from_index(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_non_empty_domain_from_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_non_empty_domain_var_size_from_index(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_non_empty_domain_var_size_from_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const*, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_non_empty_domain_var_from_index(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_non_empty_domain_var_from_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const*, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_mbr_num(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_mbr_from_index(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, unsigned int, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_mbr_from_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, char const*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_mbr_var_size_from_index(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, unsigned int, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_mbr_var_size_from_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, char const*, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_mbr_var_from_index(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, unsigned int, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_mbr_var_from_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, char const*, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_cell_num(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_total_cell_num(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_version(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_has_consolidated_metadata(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_unconsolidated_metadata_num(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_to_vacuum_num(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_to_vacuum_uri(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_array_schema(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, tiledb_array_schema_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_array_schema_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_dump(tiledb_ctx_handle_t*, tiledb_fragment_info_t const*, __sFILE*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_status_details(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_experimental_query_status_details_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_consolidation_plan_create_with_mbr(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long, tiledb_consolidation_plan_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_consolidation_plan_free(tiledb_consolidation_plan_t**))>::function_from_void(tiledb_consolidation_plan_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_consolidation_plan_get_num_nodes(tiledb_ctx_handle_t*, tiledb_consolidation_plan_t*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_consolidation_plan_get_num_fragments(tiledb_ctx_handle_t*, tiledb_consolidation_plan_t*, unsigned long long, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_consolidation_plan_get_fragment_uri(tiledb_ctx_handle_t*, tiledb_consolidation_plan_t*, unsigned long long, unsigned long long, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_consolidation_plan_dump_json_str(tiledb_ctx_handle_t*, tiledb_consolidation_plan_t const*, char**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_consolidation_plan_free_json_str(char**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::common::detail::tiledb_filestore_schema_create(tiledb_ctx_handle_t*, char const*, tiledb_array_schema_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::common::detail::tiledb_filestore_uri_import(tiledb_ctx_handle_t*, char const*, char const*, tiledb_mime_type_t)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
tiledb::api::CAPIFunction<&(tiledb::common::detail::tiledb_filestore_uri_export(tiledb_ctx_handle_t*, char const*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::common::detail::tiledb_filestore_buffer_import(tiledb_ctx_handle_t*, char const*, void*, unsigned long, tiledb_mime_type_t)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::common::detail::tiledb_filestore_buffer_export(tiledb_ctx_handle_t*, char const*, unsigned long, void*, unsigned long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::common::detail::tiledb_filestore_size(tiledb_ctx_handle_t*, char const*, unsigned long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::common::detail::tiledb_mime_type_to_str(tiledb_mime_type_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::common::detail::tiledb_mime_type_from_str(char const*, tiledb_mime_type_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_alloc(tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_buffer_free(tiledb_buffer_handle_t**))>::function_from_void(tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_set_type(tiledb_buffer_handle_t*, tiledb_datatype_t)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_get_type(tiledb_buffer_handle_t const*, tiledb_datatype_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_get_data(tiledb_buffer_handle_t const*, void**, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_set_data(tiledb_buffer_handle_t*, void*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_error_message(tiledb_error_handle_t*, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_error_free(tiledb_error_handle_t**))>::function_from_void(tiledb_error_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_alloc(tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_config_free(tiledb_config_handle_t**))>::function_from_void(tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_set(tiledb_config_handle_t*, char const*, char const*)), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_get(tiledb_config_handle_t*, char const*, char const**)), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_unset(tiledb_config_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_load_from_file(tiledb_config_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_save_to_file(tiledb_config_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_compare(tiledb_config_handle_t*, tiledb_config_handle_t*, unsigned char*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_iter_alloc(tiledb_config_handle_t*, char const*, tiledb_config_iter_handle_t**)), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_iter_reset(tiledb_config_handle_t*, tiledb_config_iter_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_config_iter_free(tiledb_config_iter_handle_t**))>::function_from_void(tiledb_config_iter_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_iter_here(tiledb_config_iter_handle_t*, char const**, char const**)), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_iter_next(tiledb_config_iter_handle_t*)), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_iter_done(tiledb_config_iter_handle_t*, int*)), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_ctx_alloc(tiledb_config_handle_t*, tiledb_ctx_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_ctx_alloc(tiledb_config_handle_t*, tiledb_ctx_handle_t**)), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_ctx_free(tiledb_ctx_handle_t**))>::function_from_void(tiledb_ctx_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_ctx_get_stats(tiledb_ctx_handle_t*, char**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_ctx_get_config(tiledb_ctx_handle_t*, tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_ctx_get_last_error(tiledb_ctx_handle_t*, tiledb_error_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_ctx_is_supported_fs(tiledb_ctx_handle_t*, tiledb_filesystem_t, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_ctx_cancel_tasks(tiledb_ctx_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_ctx_set_tag(tiledb_ctx_handle_t*, char const*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_datatype_to_str(tiledb_datatype_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_datatype_from_str(char const*, tiledb_datatype_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filesystem_to_str(tiledb_filesystem_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filesystem_from_str(char const*, tiledb_filesystem_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_alloc(tiledb_ctx_handle_t*, tiledb_filter_type_t, tiledb_filter_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_filter_free(tiledb_filter_handle_t**))>::function_from_void(tiledb_filter_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_get_type(tiledb_filter_handle_t*, tiledb_filter_type_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_set_option(tiledb_filter_handle_t*, tiledb_filter_option_t, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_get_option(tiledb_filter_handle_t*, tiledb_filter_option_t, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_type_to_str(tiledb_filter_type_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_type_from_str(char const*, tiledb_filter_type_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_option_to_str(tiledb_filter_option_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_option_from_str(char const*, tiledb_filter_option_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_list_alloc(tiledb_ctx_handle_t*, tiledb_filter_list_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_filter_list_free(tiledb_filter_list_handle_t**))>::function_from_void(tiledb_filter_list_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_list_add_filter(tiledb_filter_list_handle_t*, tiledb_filter_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_list_set_max_chunk_size(tiledb_filter_list_handle_t*, unsigned int)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_list_get_nfilters(tiledb_filter_list_handle_t const*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_list_get_filter_from_index(tiledb_filter_list_handle_t const*, unsigned int, tiledb_filter_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Line
Count
Source
413
2
  static inline Status exception_to_status(const std::exception& e) {
414
2
    return CAPIStatusError(
415
2
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
2
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_list_get_max_chunk_size(tiledb_filter_list_handle_t const*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Line
Count
Source
413
1
  static inline Status exception_to_status(const std::exception& e) {
414
1
    return CAPIStatusError(
415
1
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
1
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_create(tiledb_ctx_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_alloc(tiledb_ctx_handle_t*, char const*, tiledb_group_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_open(tiledb_group_handle_t*, tiledb_query_type_t)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_close(tiledb_group_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_group_free(tiledb_group_handle_t**))>::function_from_void(tiledb_group_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_set_config(tiledb_group_handle_t*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_config(tiledb_group_handle_t*, tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_put_metadata(tiledb_group_handle_t*, char const*, tiledb_datatype_t, unsigned int, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_delete_group(tiledb_group_handle_t*, char const*, unsigned char)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_delete_metadata(tiledb_group_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_metadata(tiledb_group_handle_t*, char const*, tiledb_datatype_t*, unsigned int*, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_metadata_num(tiledb_group_handle_t*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_metadata_from_index(tiledb_group_handle_t*, unsigned long long, char const**, unsigned int*, tiledb_datatype_t*, unsigned int*, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_has_metadata_key(tiledb_group_handle_t*, char const*, tiledb_datatype_t*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_add_member(tiledb_group_handle_t*, char const*, unsigned char, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_remove_member(tiledb_group_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_member_count(tiledb_group_handle_t*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_member_by_index(tiledb_group_handle_t*, unsigned long long, char**, tiledb_object_t*, char**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_member_by_name(tiledb_group_handle_t*, char const*, char**, tiledb_object_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_is_relative_uri_by_name(tiledb_group_handle_t*, char const*, unsigned char*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_is_open(tiledb_group_handle_t*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_uri(tiledb_group_handle_t*, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_query_type(tiledb_group_handle_t*, tiledb_query_type_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_dump_str(tiledb_group_handle_t*, char**, unsigned char)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_group(tiledb_group_handle_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_group(tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_group_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_group_metadata(tiledb_group_handle_t const*, tiledb_serialization_type_t, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_group_metadata(tiledb_group_handle_t*, tiledb_serialization_type_t, tiledb_buffer_handle_t const*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_consolidate_metadata(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_vacuum_metadata(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_object_type_to_str(tiledb_object_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_object_type_from_str(char const*, tiledb_object_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_walk_order_to_str(tiledb_walk_order_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_walk_order_from_str(char const*, tiledb_walk_order_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_type_to_str(tiledb_query_type_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_type_from_str(char const*, tiledb_query_type_t*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
tiledb::api::CAPIFunction<&(tf_always_good()), tiledb::api::detail::ExceptionActionDetailCtxErr>::exception_to_status(std::exception const&)
Line
Count
Source
413
2
  static inline Status exception_to_status(const std::exception& e) {
414
2
    return CAPIStatusError(
415
2
        std::string{"TileDB Internal, std::exception; "} + e.what());
416
2
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tf_always_throw()), tiledb::api::detail::ExceptionActionDetailCtxErr>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tf_assign(int, int*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tf_always_throw()), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tf_void_assign(int, int*))>::function_from_void(int, int*)), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tf_void_throw())>::function_from_void()), tiledb::api::detail::ExceptionActionDetail>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tf_context_assign(tiledb_ctx_handle_t*, int, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tf_context_throw(tiledb_ctx_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tf_assign(int, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tf_always_throw()), tiledb::api::detail::ExceptionActionDetailCtx>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tf_assign(int, int*)), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::exception const&)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tf_always_throw()), tiledb::api::detail::ExceptionActionDetailErr>::exception_to_status(std::exception const&)
417
418
 public:
419
  /**
420
   * Forwarded alias to template parameter H.
421
   */
422
  using handler_type = H;
423
424
  /**
425
   * The wrapper function
426
   *
427
   * @param h An error handler
428
   * @param args Arguments to an API implementation function
429
   * @return
430
   */
431
4.97M
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4.97M
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4.97M
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4.97M
      auto x{f(args...)};
454
4.97M
      h.action_on_success();
455
4.97M
      return x;
456
4.97M
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
17
    } catch (const detail::InvalidContextException& e) {
460
17
      h.action(exception_to_status(e));
461
17
      return TILEDB_INVALID_CONTEXT;
462
17
    } catch (const detail::InvalidErrorException& e) {
463
12
      h.action(exception_to_status(e));
464
12
      return TILEDB_INVALID_ERROR;
465
860
    } catch (const StatusException& e) {
466
860
      h.action(e.extract_status());
467
860
      return TILEDB_ERR;
468
860
    } catch (const std::exception& e) {
469
26
      h.action(exception_to_status(e));
470
26
      return TILEDB_ERR;
471
26
    } catch (...) {
472
6
      h.action(CAPIStatusError(
473
6
          "TileDB Internal: unknown exception type; no further information"));
474
6
      return TILEDB_ERR;
475
6
    }
476
4.97M
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_type_to_str(tiledb_array_type_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_array_type_t, char const**)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_type_from_str(char const*, tiledb_array_type_t*)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, char const*, tiledb_array_type_t*)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_layout_to_str(tiledb_layout_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_layout_t, char const**)
Line
Count
Source
431
4
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4
      auto x{f(args...)};
454
4
      h.action_on_success();
455
4
      return x;
456
4
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_layout_from_str(char const*, tiledb_layout_t*)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, char const*, tiledb_layout_t*)
Line
Count
Source
431
4
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4
      auto x{f(args...)};
454
4
      h.action_on_success();
455
4
      return x;
456
4
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_encryption_type_to_str(tiledb_encryption_type_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_encryption_type_t, char const**)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_encryption_type_from_str(char const*, tiledb_encryption_type_t*)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, char const*, tiledb_encryption_type_t*)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_status_to_str(tiledb_query_status_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_query_status_t, char const**)
Line
Count
Source
431
5
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
5
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
5
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
5
      auto x{f(args...)};
454
5
      h.action_on_success();
455
5
      return x;
456
5
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
5
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_status_from_str(char const*, tiledb_query_status_t*)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, char const*, tiledb_query_status_t*)
Line
Count
Source
431
5
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
5
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
5
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
5
      auto x{f(args...)};
454
5
      h.action_on_success();
455
5
      return x;
456
5
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
5
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialization_type_to_str(tiledb_serialization_type_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_serialization_type_t, char const**)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialization_type_from_str(char const*, tiledb_serialization_type_t*)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, char const*, tiledb_serialization_type_t*)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_mode_to_str(tiledb_vfs_mode_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_vfs_mode_t, char const**)
Line
Count
Source
431
3
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
3
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
3
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
3
      auto x{f(args...)};
454
3
      h.action_on_success();
455
3
      return x;
456
3
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
3
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_mode_from_str(char const*, tiledb_vfs_mode_t*)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, char const*, tiledb_vfs_mode_t*)
Line
Count
Source
431
3
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
3
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
3
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
3
      auto x{f(args...)};
454
3
      h.action_on_success();
455
3
      return x;
456
3
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
3
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_list_alloc(tiledb_ctx_handle_t*, tiledb_buffer_list_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_buffer_list_t**)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_buffer_list_free(tiledb_buffer_list_t**))>::function_from_void(tiledb_buffer_list_t**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_buffer_list_t**)
Line
Count
Source
431
2.42k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2.42k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2.42k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2.42k
      auto x{f(args...)};
454
2.42k
      h.action_on_success();
455
2.42k
      return x;
456
2.42k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2.42k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_list_get_num_buffers(tiledb_ctx_handle_t*, tiledb_buffer_list_t const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_buffer_list_t const*, unsigned long long*)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_list_get_buffer(tiledb_ctx_handle_t*, tiledb_buffer_list_t const*, unsigned long long, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_buffer_list_t const*, unsigned long long, tiledb_buffer_handle_t**)
Line
Count
Source
431
4
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4
      auto x{f(args...)};
454
4
      h.action_on_success();
455
4
      return x;
456
4
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
2
    } catch (const StatusException& e) {
466
2
      h.action(e.extract_status());
467
2
      return TILEDB_ERR;
468
2
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_list_get_total_size(tiledb_ctx_handle_t*, tiledb_buffer_list_t const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_buffer_list_t const*, unsigned long long*)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_list_flatten(tiledb_ctx_handle_t*, tiledb_buffer_list_t const*, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_buffer_list_t const*, tiledb_buffer_handle_t**)
Line
Count
Source
431
2.42k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2.42k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2.42k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2.42k
      auto x{f(args...)};
454
2.42k
      h.action_on_success();
455
2.42k
      return x;
456
2.42k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2.42k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_alloc(tiledb_ctx_handle_t*, char const*, tiledb_datatype_t, tiledb_attribute_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, tiledb_datatype_t, tiledb_attribute_t**)
Line
Count
Source
431
15.9k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
15.9k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
15.9k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
15.9k
      auto x{f(args...)};
454
15.9k
      h.action_on_success();
455
15.9k
      return x;
456
15.9k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
15.9k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_attribute_free(tiledb_attribute_t**))>::function_from_void(tiledb_attribute_t**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_attribute_t**)
Line
Count
Source
431
20.6k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
20.6k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
20.6k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
20.6k
      auto x{f(args...)};
454
20.6k
      h.action_on_success();
455
20.6k
      return x;
456
20.6k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
20.6k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_set_nullable(tiledb_ctx_handle_t*, tiledb_attribute_t*, unsigned char)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_attribute_t*, unsigned char)
Line
Count
Source
431
6.17k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
6.17k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
6.17k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
6.17k
      auto x{f(args...)};
454
6.17k
      h.action_on_success();
455
6.17k
      return x;
456
6.17k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
6.17k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_set_filter_list(tiledb_ctx_handle_t*, tiledb_attribute_t*, tiledb_filter_list_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_attribute_t*, tiledb_filter_list_handle_t*)
Line
Count
Source
431
2.52k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2.52k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2.52k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2.52k
      auto x{f(args...)};
454
2.52k
      h.action_on_success();
455
2.52k
      return x;
456
2.52k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2.52k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_set_cell_val_num(tiledb_ctx_handle_t*, tiledb_attribute_t*, unsigned int)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_attribute_t*, unsigned int)
Line
Count
Source
431
15.6k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
15.6k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
15.6k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
15.6k
      auto x{f(args...)};
454
15.6k
      h.action_on_success();
455
15.6k
      return x;
456
15.6k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
2
    } catch (const StatusException& e) {
466
2
      h.action(e.extract_status());
467
2
      return TILEDB_ERR;
468
2
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
15.6k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_get_name(tiledb_ctx_handle_t*, tiledb_attribute_t const*, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_attribute_t const*, char const**)
Line
Count
Source
431
230
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
230
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
230
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
230
      auto x{f(args...)};
454
230
      h.action_on_success();
455
230
      return x;
456
230
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
230
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_get_type(tiledb_ctx_handle_t*, tiledb_attribute_t const*, tiledb_datatype_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_attribute_t const*, tiledb_datatype_t*)
Line
Count
Source
431
389
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
389
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
389
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
389
      auto x{f(args...)};
454
389
      h.action_on_success();
455
389
      return x;
456
389
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
389
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_get_nullable(tiledb_ctx_handle_t*, tiledb_attribute_t*, unsigned char*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_attribute_t*, unsigned char*)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_get_filter_list(tiledb_ctx_handle_t*, tiledb_attribute_t*, tiledb_filter_list_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_attribute_t*, tiledb_filter_list_handle_t**)
Line
Count
Source
431
14
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
14
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
14
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
14
      auto x{f(args...)};
454
14
      h.action_on_success();
455
14
      return x;
456
14
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
14
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_get_cell_val_num(tiledb_ctx_handle_t*, tiledb_attribute_t const*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_attribute_t const*, unsigned int*)
Line
Count
Source
431
4.30k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4.30k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4.30k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4.30k
      auto x{f(args...)};
454
4.30k
      h.action_on_success();
455
4.30k
      return x;
456
4.30k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4.30k
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_get_cell_size(tiledb_ctx_handle_t*, tiledb_attribute_t const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_attribute_t const*, unsigned long long*)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_dump(tiledb_ctx_handle_t*, tiledb_attribute_t const*, __sFILE*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_attribute_t const*, __sFILE*)
Line
Count
Source
431
18
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
18
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
18
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
18
      auto x{f(args...)};
454
18
      h.action_on_success();
455
18
      return x;
456
18
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
18
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_set_fill_value(tiledb_ctx_handle_t*, tiledb_attribute_t*, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_attribute_t*, void const*, unsigned long long)
Line
Count
Source
431
82
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
82
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
82
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
82
      auto x{f(args...)};
454
82
      h.action_on_success();
455
82
      return x;
456
82
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
8
    } catch (const StatusException& e) {
466
8
      h.action(e.extract_status());
467
8
      return TILEDB_ERR;
468
8
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
82
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_get_fill_value(tiledb_ctx_handle_t*, tiledb_attribute_t*, void const**, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_attribute_t*, void const**, unsigned long long*)
Line
Count
Source
431
16
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
16
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
16
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
16
      auto x{f(args...)};
454
16
      h.action_on_success();
455
16
      return x;
456
16
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
2
    } catch (const StatusException& e) {
466
2
      h.action(e.extract_status());
467
2
      return TILEDB_ERR;
468
2
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
16
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_set_fill_value_nullable(tiledb_ctx_handle_t*, tiledb_attribute_t*, void const*, unsigned long long, unsigned char)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_attribute_t*, void const*, unsigned long long, unsigned char)
Line
Count
Source
431
41
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
41
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
41
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
41
      auto x{f(args...)};
454
41
      h.action_on_success();
455
41
      return x;
456
41
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
8
    } catch (const StatusException& e) {
466
8
      h.action(e.extract_status());
467
8
      return TILEDB_ERR;
468
8
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
41
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_attribute_get_fill_value_nullable(tiledb_ctx_handle_t*, tiledb_attribute_t*, void const**, unsigned long long*, unsigned char*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_attribute_t*, void const**, unsigned long long*, unsigned char*)
Line
Count
Source
431
8
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
8
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
8
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
8
      auto x{f(args...)};
454
8
      h.action_on_success();
455
8
      return x;
456
8
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
2
    } catch (const StatusException& e) {
466
2
      h.action(e.extract_status());
467
2
      return TILEDB_ERR;
468
2
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
8
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_domain_alloc(tiledb_ctx_handle_t*, tiledb_domain_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_domain_t**)
Line
Count
Source
431
9.39k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
9.39k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
9.39k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
9.39k
      auto x{f(args...)};
454
9.39k
      h.action_on_success();
455
9.39k
      return x;
456
9.39k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
9.39k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_domain_free(tiledb_domain_t**))>::function_from_void(tiledb_domain_t**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_domain_t**)
Line
Count
Source
431
29.1k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
29.1k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
29.1k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
29.1k
      auto x{f(args...)};
454
29.1k
      h.action_on_success();
455
29.1k
      return x;
456
29.1k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
29.1k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_domain_get_type(tiledb_ctx_handle_t*, tiledb_domain_t const*, tiledb_datatype_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_domain_t const*, tiledb_datatype_t*)
Line
Count
Source
431
545
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
545
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
545
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
545
      auto x{f(args...)};
454
545
      h.action_on_success();
455
545
      return x;
456
545
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
545
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_domain_get_ndim(tiledb_ctx_handle_t*, tiledb_domain_t const*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_domain_t const*, unsigned int*)
Line
Count
Source
431
474
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
474
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
474
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
474
      auto x{f(args...)};
454
474
      h.action_on_success();
455
474
      return x;
456
474
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
474
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_domain_add_dimension(tiledb_ctx_handle_t*, tiledb_domain_t*, tiledb_dimension_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_domain_t*, tiledb_dimension_t*)
Line
Count
Source
431
17.9k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
17.9k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
17.9k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
17.9k
      auto x{f(args...)};
454
17.9k
      h.action_on_success();
455
17.9k
      return x;
456
17.9k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
17.9k
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_domain_dump(tiledb_ctx_handle_t*, tiledb_domain_t const*, __sFILE*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_domain_t const*, __sFILE*)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_alloc(tiledb_ctx_handle_t*, char const*, tiledb_datatype_t, void const*, void const*, tiledb_dimension_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, tiledb_datatype_t, void const*, void const*, tiledb_dimension_t**)
Line
Count
Source
431
17.9k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
17.9k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
17.9k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
17.9k
      auto x{f(args...)};
454
17.9k
      h.action_on_success();
455
17.9k
      return x;
456
17.9k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
4
    } catch (const std::exception& e) {
469
4
      h.action(exception_to_status(e));
470
4
      return TILEDB_ERR;
471
4
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
17.9k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_dimension_free(tiledb_dimension_t**))>::function_from_void(tiledb_dimension_t**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_dimension_t**)
Line
Count
Source
431
27.2k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
27.2k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
27.2k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
27.2k
      auto x{f(args...)};
454
27.2k
      h.action_on_success();
455
27.2k
      return x;
456
27.2k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
27.2k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_set_filter_list(tiledb_ctx_handle_t*, tiledb_dimension_t*, tiledb_filter_list_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_dimension_t*, tiledb_filter_list_handle_t*)
Line
Count
Source
431
88
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
88
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
88
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
88
      auto x{f(args...)};
454
88
      h.action_on_success();
455
88
      return x;
456
88
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
5
    } catch (const StatusException& e) {
466
5
      h.action(e.extract_status());
467
5
      return TILEDB_ERR;
468
5
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
88
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_set_cell_val_num(tiledb_ctx_handle_t*, tiledb_dimension_t*, unsigned int)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_dimension_t*, unsigned int)
Line
Count
Source
431
16
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
16
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
16
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
16
      auto x{f(args...)};
454
16
      h.action_on_success();
455
16
      return x;
456
16
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
7
    } catch (const StatusException& e) {
466
7
      h.action(e.extract_status());
467
7
      return TILEDB_ERR;
468
7
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
16
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_get_filter_list(tiledb_ctx_handle_t*, tiledb_dimension_t*, tiledb_filter_list_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_dimension_t*, tiledb_filter_list_handle_t**)
Line
Count
Source
431
4
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4
      auto x{f(args...)};
454
4
      h.action_on_success();
455
4
      return x;
456
4
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_get_cell_val_num(tiledb_ctx_handle_t*, tiledb_dimension_t const*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_dimension_t const*, unsigned int*)
Line
Count
Source
431
5.10k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
5.10k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
5.10k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
5.10k
      auto x{f(args...)};
454
5.10k
      h.action_on_success();
455
5.10k
      return x;
456
5.10k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
5.10k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_get_name(tiledb_ctx_handle_t*, tiledb_dimension_t const*, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_dimension_t const*, char const**)
Line
Count
Source
431
183
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
183
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
183
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
183
      auto x{f(args...)};
454
183
      h.action_on_success();
455
183
      return x;
456
183
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
183
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_get_type(tiledb_ctx_handle_t*, tiledb_dimension_t const*, tiledb_datatype_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_dimension_t const*, tiledb_datatype_t*)
Line
Count
Source
431
4.07k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4.07k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4.07k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4.07k
      auto x{f(args...)};
454
4.07k
      h.action_on_success();
455
4.07k
      return x;
456
4.07k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4.07k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_get_domain(tiledb_ctx_handle_t*, tiledb_dimension_t const*, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_dimension_t const*, void const**)
Line
Count
Source
431
20
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
20
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
20
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
20
      auto x{f(args...)};
454
20
      h.action_on_success();
455
20
      return x;
456
20
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
20
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_get_tile_extent(tiledb_ctx_handle_t*, tiledb_dimension_t const*, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_dimension_t const*, void const**)
Line
Count
Source
431
23
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
23
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
23
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
23
      auto x{f(args...)};
454
23
      h.action_on_success();
455
23
      return x;
456
23
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
23
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_dimension_dump(tiledb_ctx_handle_t*, tiledb_dimension_t const*, __sFILE*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_dimension_t const*, __sFILE*)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_domain_get_dimension_from_index(tiledb_ctx_handle_t*, tiledb_domain_t const*, unsigned int, tiledb_dimension_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_domain_t const*, unsigned int, tiledb_dimension_t**)
Line
Count
Source
431
1.01k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
1.01k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
1.01k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
1.01k
      auto x{f(args...)};
454
1.01k
      h.action_on_success();
455
1.01k
      return x;
456
1.01k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
1.01k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_domain_get_dimension_from_name(tiledb_ctx_handle_t*, tiledb_domain_t const*, char const*, tiledb_dimension_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_domain_t const*, char const*, tiledb_dimension_t**)
Line
Count
Source
431
8.33k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
8.33k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
8.33k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
8.33k
      auto x{f(args...)};
454
8.33k
      h.action_on_success();
455
8.33k
      return x;
456
8.33k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
8.33k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_domain_has_dimension(tiledb_ctx_handle_t*, tiledb_domain_t const*, char const*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_domain_t const*, char const*, int*)
Line
Count
Source
431
9.63k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
9.63k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
9.63k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
9.63k
      auto x{f(args...)};
454
9.63k
      h.action_on_success();
455
9.63k
      return x;
456
9.63k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
9.63k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_alloc(tiledb_ctx_handle_t*, tiledb_array_type_t, tiledb_array_schema_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_type_t, tiledb_array_schema_t**)
Line
Count
Source
431
9.39k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
9.39k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
9.39k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
9.39k
      auto x{f(args...)};
454
9.39k
      h.action_on_success();
455
9.39k
      return x;
456
9.39k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
9.39k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_array_schema_free(tiledb_array_schema_t**))>::function_from_void(tiledb_array_schema_t**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_array_schema_t**)
Line
Count
Source
431
58.1k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
58.1k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
58.1k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
58.1k
      auto x{f(args...)};
454
58.1k
      h.action_on_success();
455
58.1k
      return x;
456
58.1k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
58.1k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_add_attribute(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_attribute_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_attribute_t*)
Line
Count
Source
431
15.8k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
15.8k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
15.8k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
15.8k
      auto x{f(args...)};
454
15.8k
      h.action_on_success();
455
15.8k
      return x;
456
15.8k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
2
    } catch (const StatusException& e) {
466
2
      h.action(e.extract_status());
467
2
      return TILEDB_ERR;
468
2
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
15.8k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_set_allows_dups(tiledb_ctx_handle_t*, tiledb_array_schema_t*, int)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t*, int)
Line
Count
Source
431
5.42k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
5.42k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
5.42k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
5.42k
      auto x{f(args...)};
454
5.42k
      h.action_on_success();
455
5.42k
      return x;
456
5.42k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
3
    } catch (const StatusException& e) {
466
3
      h.action(e.extract_status());
467
3
      return TILEDB_ERR;
468
3
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
5.42k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_allows_dups(tiledb_ctx_handle_t*, tiledb_array_schema_t*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t*, int*)
Line
Count
Source
431
11
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
11
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
11
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
11
      auto x{f(args...)};
454
11
      h.action_on_success();
455
11
      return x;
456
11
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
11
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_version(tiledb_ctx_handle_t*, tiledb_array_schema_t*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t*, unsigned int*)
Line
Count
Source
431
4
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4
      auto x{f(args...)};
454
4
      h.action_on_success();
455
4
      return x;
456
4
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_set_domain(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_domain_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_domain_t*)
Line
Count
Source
431
9.39k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
9.39k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
9.39k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
9.39k
      auto x{f(args...)};
454
9.39k
      h.action_on_success();
455
9.39k
      return x;
456
9.39k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
6
    } catch (const StatusException& e) {
466
6
      h.action(e.extract_status());
467
6
      return TILEDB_ERR;
468
6
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
9.39k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_set_capacity(tiledb_ctx_handle_t*, tiledb_array_schema_t*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t*, unsigned long long)
Line
Count
Source
431
2.15k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2.15k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2.15k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2.15k
      auto x{f(args...)};
454
2.15k
      h.action_on_success();
455
2.15k
      return x;
456
2.15k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2.15k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_set_cell_order(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_layout_t)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_layout_t)
Line
Count
Source
431
7.76k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
7.76k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
7.76k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
7.76k
      auto x{f(args...)};
454
7.76k
      h.action_on_success();
455
7.76k
      return x;
456
7.76k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
7.76k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_set_tile_order(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_layout_t)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_layout_t)
Line
Count
Source
431
7.00k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
7.00k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
7.00k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
7.00k
      auto x{f(args...)};
454
7.00k
      h.action_on_success();
455
7.00k
      return x;
456
7.00k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
7.00k
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_timestamp_range(tiledb_ctx_handle_t*, tiledb_array_schema_t*, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t*, unsigned long long*, unsigned long long*)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_set_coords_filter_list(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t*)
Line
Count
Source
431
629
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
629
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
629
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
629
      auto x{f(args...)};
454
629
      h.action_on_success();
455
629
      return x;
456
629
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
4
    } catch (const StatusException& e) {
466
4
      h.action(e.extract_status());
467
4
      return TILEDB_ERR;
468
4
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
629
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_set_offsets_filter_list(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t*)
Line
Count
Source
431
7
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
7
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
7
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
7
      auto x{f(args...)};
454
7
      h.action_on_success();
455
7
      return x;
456
7
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
7
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_set_validity_filter_list(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t*)
Line
Count
Source
431
3
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
3
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
3
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
3
      auto x{f(args...)};
454
3
      h.action_on_success();
455
3
      return x;
456
3
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
3
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_check(tiledb_ctx_handle_t*, tiledb_array_schema_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t*)
Line
Count
Source
431
9.26k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
9.26k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
9.26k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
9.26k
      auto x{f(args...)};
454
9.26k
      h.action_on_success();
455
9.26k
      return x;
456
9.26k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
5
    } catch (const StatusException& e) {
466
5
      h.action(e.extract_status());
467
5
      return TILEDB_ERR;
468
5
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
9.26k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_load(tiledb_ctx_handle_t*, char const*, tiledb_array_schema_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, tiledb_array_schema_t**)
Line
Count
Source
431
31
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
31
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
31
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
31
      auto x{f(args...)};
454
31
      h.action_on_success();
455
31
      return x;
456
31
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
31
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_load_with_key(tiledb_ctx_handle_t*, char const*, tiledb_encryption_type_t, void const*, unsigned int, tiledb_array_schema_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, tiledb_encryption_type_t, void const*, unsigned int, tiledb_array_schema_t**)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_array_type(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_array_type_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_array_type_t*)
Line
Count
Source
431
9
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
9
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
9
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
9
      auto x{f(args...)};
454
9
      h.action_on_success();
455
9
      return x;
456
9
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
9
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_capacity(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t const*, unsigned long long*)
Line
Count
Source
431
3
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
3
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
3
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
3
      auto x{f(args...)};
454
3
      h.action_on_success();
455
3
      return x;
456
3
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
3
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_cell_order(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_layout_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_layout_t*)
Line
Count
Source
431
6
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
6
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
6
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
6
      auto x{f(args...)};
454
6
      h.action_on_success();
455
6
      return x;
456
6
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
6
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_coords_filter_list(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t**)
Line
Count
Source
431
7
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
7
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
7
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
7
      auto x{f(args...)};
454
7
      h.action_on_success();
455
7
      return x;
456
7
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
7
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_offsets_filter_list(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t**)
Line
Count
Source
431
6
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
6
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
6
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
6
      auto x{f(args...)};
454
6
      h.action_on_success();
455
6
      return x;
456
6
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
6
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_validity_filter_list(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t**)
Line
Count
Source
431
3
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
3
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
3
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
3
      auto x{f(args...)};
454
3
      h.action_on_success();
455
3
      return x;
456
3
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
3
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_domain(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_domain_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_domain_t**)
Line
Count
Source
431
19.7k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
19.7k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
19.7k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
19.7k
      auto x{f(args...)};
454
19.7k
      h.action_on_success();
455
19.7k
      return x;
456
19.7k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
19.7k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_tile_order(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_layout_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_layout_t*)
Line
Count
Source
431
4
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4
      auto x{f(args...)};
454
4
      h.action_on_success();
455
4
      return x;
456
4
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_attribute_num(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t const*, unsigned int*)
Line
Count
Source
431
108
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
108
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
108
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
108
      auto x{f(args...)};
454
108
      h.action_on_success();
455
108
      return x;
456
108
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
108
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_dump(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, __sFILE*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t const*, __sFILE*)
Line
Count
Source
431
11
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
11
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
11
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
11
      auto x{f(args...)};
454
11
      h.action_on_success();
455
11
      return x;
456
11
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
11
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_attribute_from_index(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, unsigned int, tiledb_attribute_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t const*, unsigned int, tiledb_attribute_t**)
Line
Count
Source
431
224
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
224
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
224
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
224
      auto x{f(args...)};
454
224
      h.action_on_success();
455
224
      return x;
456
224
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
224
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_get_attribute_from_name(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, char const*, tiledb_attribute_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t const*, char const*, tiledb_attribute_t**)
Line
Count
Source
431
4.51k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4.51k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4.51k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4.51k
      auto x{f(args...)};
454
4.51k
      h.action_on_success();
455
4.51k
      return x;
456
4.51k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4.51k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_has_attribute(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, char const*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t const*, char const*, int*)
Line
Count
Source
431
10.6k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
10.6k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
10.6k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
10.6k
      auto x{f(args...)};
454
10.6k
      h.action_on_success();
455
10.6k
      return x;
456
10.6k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
10.6k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_evolution_alloc(tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t**)
Line
Count
Source
431
13
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
13
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
13
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
13
      auto x{f(args...)};
454
13
      h.action_on_success();
455
13
      return x;
456
13
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
13
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_array_schema_evolution_free(tiledb_array_schema_evolution_t**))>::function_from_void(tiledb_array_schema_evolution_t**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_array_schema_evolution_t**)
Line
Count
Source
431
13
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
13
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
13
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
13
      auto x{f(args...)};
454
13
      h.action_on_success();
455
13
      return x;
456
13
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
13
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_evolution_add_attribute(tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t*, tiledb_attribute_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t*, tiledb_attribute_t*)
Line
Count
Source
431
37
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
37
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
37
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
37
      auto x{f(args...)};
454
37
      h.action_on_success();
455
37
      return x;
456
37
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
37
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_evolution_drop_attribute(tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t*, char const*)
Line
Count
Source
431
5
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
5
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
5
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
5
      auto x{f(args...)};
454
5
      h.action_on_success();
455
5
      return x;
456
5
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
5
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_schema_evolution_set_timestamp_range(tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t*, unsigned long long, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t*, unsigned long long, unsigned long long)
Line
Count
Source
431
13
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
13
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
13
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
13
      auto x{f(args...)};
454
13
      h.action_on_success();
455
13
      return x;
456
13
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
13
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_alloc(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t, tiledb_query_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t, tiledb_query_t**)
Line
Count
Source
431
27.9k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
27.9k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
27.9k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
27.9k
      auto x{f(args...)};
454
27.9k
      h.action_on_success();
455
27.9k
      return x;
456
27.9k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
27.9k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_stats(tiledb_ctx_handle_t*, tiledb_query_t*, char**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, char**)
Line
Count
Source
431
998
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
998
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
998
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
998
      auto x{f(args...)};
454
998
      h.action_on_success();
455
998
      return x;
456
998
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
998
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_config(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_config_handle_t*)
Line
Count
Source
431
13
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
13
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
13
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
13
      auto x{f(args...)};
454
13
      h.action_on_success();
455
13
      return x;
456
13
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
13
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_config(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_config_handle_t**)
Line
Count
Source
431
1
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
1
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
1
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
1
      auto x{f(args...)};
454
1
      h.action_on_success();
455
1
      return x;
456
1
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
1
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_subarray(tiledb_ctx_handle_t*, tiledb_query_t*, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, void const*)
Line
Count
Source
431
6.92k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
6.92k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
6.92k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
6.92k
      auto x{f(args...)};
454
6.92k
      h.action_on_success();
455
6.92k
      return x;
456
6.92k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
22
    } catch (const StatusException& e) {
466
22
      h.action(e.extract_status());
467
22
      return TILEDB_ERR;
468
22
    } catch (const std::exception& e) {
469
1
      h.action(exception_to_status(e));
470
1
      return TILEDB_ERR;
471
1
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
6.92k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_subarray_t(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_subarray_t const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_subarray_t const*)
Line
Count
Source
431
4.25k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4.25k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4.25k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4.25k
      auto x{f(args...)};
454
4.25k
      h.action_on_success();
455
4.25k
      return x;
456
4.25k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4.25k
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void*, unsigned long long*)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_buffer_var(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long*, unsigned long long*, void*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long*, unsigned long long*, void*, unsigned long long*)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_buffer_nullable(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void*, unsigned long long*, unsigned char*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void*, unsigned long long*, unsigned char*, unsigned long long*)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_buffer_var_nullable(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long*, unsigned long long*, void*, unsigned long long*, unsigned char*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long*, unsigned long long*, void*, unsigned long long*, unsigned char*, unsigned long long*)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_data_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void*, unsigned long long*)
Line
Count
Source
431
72.6k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
72.6k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
72.6k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
72.6k
      auto x{f(args...)};
454
72.6k
      h.action_on_success();
455
72.6k
      return x;
456
72.6k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
16
    } catch (const StatusException& e) {
466
16
      h.action(e.extract_status());
467
16
      return TILEDB_ERR;
468
16
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
72.6k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_offsets_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long*, unsigned long long*)
Line
Count
Source
431
9.40k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
9.40k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
9.40k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
9.40k
      auto x{f(args...)};
454
9.40k
      h.action_on_success();
455
9.40k
      return x;
456
9.40k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
6
    } catch (const StatusException& e) {
466
6
      h.action(e.extract_status());
467
6
      return TILEDB_ERR;
468
6
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
9.40k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_validity_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned char*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned char*, unsigned long long*)
Line
Count
Source
431
12.3k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
12.3k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
12.3k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
12.3k
      auto x{f(args...)};
454
12.3k
      h.action_on_success();
455
12.3k
      return x;
456
12.3k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
12.3k
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void**, unsigned long long**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void**, unsigned long long**)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_buffer_var(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long**, unsigned long long**, void**, unsigned long long**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long**, unsigned long long**, void**, unsigned long long**)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_buffer_nullable(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void**, unsigned long long**, unsigned char**, unsigned long long**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void**, unsigned long long**, unsigned char**, unsigned long long**)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_buffer_var_nullable(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long**, unsigned long long**, void**, unsigned long long**, unsigned char**, unsigned long long**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long**, unsigned long long**, void**, unsigned long long**, unsigned char**, unsigned long long**)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_data_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void**, unsigned long long**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void**, unsigned long long**)
Line
Count
Source
431
540
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
540
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
540
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
540
      auto x{f(args...)};
454
540
      h.action_on_success();
455
540
      return x;
456
540
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
11
    } catch (const StatusException& e) {
466
11
      h.action(e.extract_status());
467
11
      return TILEDB_ERR;
468
11
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
540
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_offsets_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long**, unsigned long long**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long**, unsigned long long**)
Line
Count
Source
431
99
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
99
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
99
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
99
      auto x{f(args...)};
454
99
      h.action_on_success();
455
99
      return x;
456
99
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
10
    } catch (const StatusException& e) {
466
10
      h.action(e.extract_status());
467
10
      return TILEDB_ERR;
468
10
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
99
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_validity_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned char**, unsigned long long**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned char**, unsigned long long**)
Line
Count
Source
431
28
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
28
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
28
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
28
      auto x{f(args...)};
454
28
      h.action_on_success();
455
28
      return x;
456
28
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
28
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_layout(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_layout_t)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_layout_t)
Line
Count
Source
431
21.8k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
21.8k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
21.8k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
21.8k
      auto x{f(args...)};
454
21.8k
      h.action_on_success();
455
21.8k
      return x;
456
21.8k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
6
    } catch (const StatusException& e) {
466
6
      h.action(e.extract_status());
467
6
      return TILEDB_ERR;
468
6
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
21.8k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_set_condition(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_query_condition_t const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_query_condition_t const*)
Line
Count
Source
431
5.17k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
5.17k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
5.17k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
5.17k
      auto x{f(args...)};
454
5.17k
      h.action_on_success();
455
5.17k
      return x;
456
5.17k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
5.17k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_finalize(tiledb_ctx_handle_t*, tiledb_query_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*)
Line
Count
Source
431
19.6k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
19.6k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
19.6k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
19.6k
      auto x{f(args...)};
454
19.6k
      h.action_on_success();
455
19.6k
      return x;
456
19.6k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
2
    } catch (const std::exception& e) {
469
2
      h.action(exception_to_status(e));
470
2
      return TILEDB_ERR;
471
2
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
19.6k
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_submit_and_finalize(tiledb_ctx_handle_t*, tiledb_query_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*)
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_query_free(tiledb_query_t**))>::function_from_void(tiledb_query_t**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_query_t**)
Line
Count
Source
431
27.9k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
27.9k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
27.9k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
27.9k
      auto x{f(args...)};
454
27.9k
      h.action_on_success();
455
27.9k
      return x;
456
27.9k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
27.9k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_submit(tiledb_ctx_handle_t*, tiledb_query_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*)
Line
Count
Source
431
27.0k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
27.0k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
27.0k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
27.0k
      auto x{f(args...)};
454
27.0k
      h.action_on_success();
455
27.0k
      return x;
456
27.0k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
128
    } catch (const StatusException& e) {
466
128
      h.action(e.extract_status());
467
128
      return TILEDB_ERR;
468
128
    } catch (const std::exception& e) {
469
1
      h.action(exception_to_status(e));
470
1
      return TILEDB_ERR;
471
1
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
27.0k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_submit_async(tiledb_ctx_handle_t*, tiledb_query_t*, void (*)(void*), void*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, void (*)(void*), void*)
Line
Count
Source
431
90
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
90
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
90
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
90
      auto x{f(args...)};
454
90
      h.action_on_success();
455
90
      return x;
456
90
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
90
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_has_results(tiledb_ctx_handle_t*, tiledb_query_t*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, int*)
Line
Count
Source
431
115
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
115
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
115
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
115
      auto x{f(args...)};
454
115
      h.action_on_success();
455
115
      return x;
456
115
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
115
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_status(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_query_status_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_query_status_t*)
Line
Count
Source
431
3.97M
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
3.97M
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
3.97M
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
3.97M
      auto x{f(args...)};
454
3.97M
      h.action_on_success();
455
3.97M
      return x;
456
3.97M
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
3.97M
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_type(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_query_type_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_query_type_t*)
Line
Count
Source
431
1.16k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
1.16k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
1.16k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
1.16k
      auto x{f(args...)};
454
1.16k
      h.action_on_success();
455
1.16k
      return x;
456
1.16k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
1.16k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_layout(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_layout_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_layout_t*)
Line
Count
Source
431
122
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
122
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
122
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
122
      auto x{f(args...)};
454
122
      h.action_on_success();
455
122
      return x;
456
122
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
122
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_array(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_array_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_array_t**)
Line
Count
Source
431
1
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
1
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
1
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
1
      auto x{f(args...)};
454
1
      h.action_on_success();
455
1
      return x;
456
1
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
1
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_add_range(tiledb_ctx_handle_t*, tiledb_query_t*, unsigned int, void const*, void const*, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, unsigned int, void const*, void const*, void const*)
Line
Count
Source
431
808
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
808
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
808
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
808
      auto x{f(args...)};
454
808
      h.action_on_success();
455
808
      return x;
456
808
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
808
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_add_point_ranges(tiledb_ctx_handle_t*, tiledb_query_t*, unsigned int, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, unsigned int, void const*, unsigned long long)
Line
Count
Source
431
4
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4
      auto x{f(args...)};
454
4
      h.action_on_success();
455
4
      return x;
456
4
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_add_range_by_name(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void const*, void const*, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void const*, void const*, void const*)
Line
Count
Source
431
2.97k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2.97k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2.97k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2.97k
      auto x{f(args...)};
454
2.97k
      h.action_on_success();
455
2.97k
      return x;
456
2.97k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2.97k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_add_range_var(tiledb_ctx_handle_t*, tiledb_query_t*, unsigned int, void const*, unsigned long long, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, unsigned int, void const*, unsigned long long, void const*, unsigned long long)
Line
Count
Source
431
230
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
230
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
230
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
230
      auto x{f(args...)};
454
230
      h.action_on_success();
455
230
      return x;
456
230
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
230
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_add_range_var_by_name(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void const*, unsigned long long, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void const*, unsigned long long, void const*, unsigned long long)
Line
Count
Source
431
141
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
141
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
141
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
141
      auto x{f(args...)};
454
141
      h.action_on_success();
455
141
      return x;
456
141
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
141
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_range_num(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int, unsigned long long*)
Line
Count
Source
431
133
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
133
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
133
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
133
      auto x{f(args...)};
454
133
      h.action_on_success();
455
133
      return x;
456
133
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
133
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_range_num_from_name(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*)
Line
Count
Source
431
4
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4
      auto x{f(args...)};
454
4
      h.action_on_success();
455
4
      return x;
456
4
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_range(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int, unsigned long long, void const**, void const**, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int, unsigned long long, void const**, void const**, void const**)
Line
Count
Source
431
65
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
65
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
65
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
65
      auto x{f(args...)};
454
65
      h.action_on_success();
455
65
      return x;
456
65
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
65
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_range_from_name(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long, void const**, void const**, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long, void const**, void const**, void const**)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_range_var_size(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int, unsigned long long, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int, unsigned long long, unsigned long long*, unsigned long long*)
Line
Count
Source
431
172
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
172
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
172
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
172
      auto x{f(args...)};
454
172
      h.action_on_success();
455
172
      return x;
456
172
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
172
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_range_var_size_from_name(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long, unsigned long long*, unsigned long long*)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_range_var(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int, unsigned long long, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int, unsigned long long, void*, void*)
Line
Count
Source
431
172
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
172
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
172
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
172
      auto x{f(args...)};
454
172
      h.action_on_success();
455
172
      return x;
456
172
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
172
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_range_var_from_name(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long, void*, void*)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_est_result_size(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*)
Line
Count
Source
431
221
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
221
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
221
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
221
      auto x{f(args...)};
454
221
      h.action_on_success();
455
221
      return x;
456
221
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
26
    } catch (const StatusException& e) {
466
26
      h.action(e.extract_status());
467
26
      return TILEDB_ERR;
468
26
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
221
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_est_result_size_var(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*, unsigned long long*)
Line
Count
Source
431
101
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
101
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
101
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
101
      auto x{f(args...)};
454
101
      h.action_on_success();
455
101
      return x;
456
101
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
14
    } catch (const StatusException& e) {
466
14
      h.action(e.extract_status());
467
14
      return TILEDB_ERR;
468
14
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
101
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_est_result_size_nullable(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*, unsigned long long*)
Line
Count
Source
431
6
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
6
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
6
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
6
      auto x{f(args...)};
454
6
      h.action_on_success();
455
6
      return x;
456
6
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
6
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_est_result_size_var_nullable(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*, unsigned long long*, unsigned long long*)
Line
Count
Source
431
3
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
3
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
3
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
3
      auto x{f(args...)};
454
3
      h.action_on_success();
455
3
      return x;
456
3
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
3
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_fragment_num(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int*)
Line
Count
Source
431
10
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
10
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
10
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
10
      auto x{f(args...)};
454
10
      h.action_on_success();
455
10
      return x;
456
10
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
3
    } catch (const StatusException& e) {
466
3
      h.action(e.extract_status());
467
3
      return TILEDB_ERR;
468
3
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
10
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_fragment_uri(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned long long, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned long long, char const**)
Line
Count
Source
431
232
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
232
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
232
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
232
      auto x{f(args...)};
454
232
      h.action_on_success();
455
232
      return x;
456
232
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
8
    } catch (const StatusException& e) {
466
8
      h.action(e.extract_status());
467
8
      return TILEDB_ERR;
468
8
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
232
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_fragment_timestamp_range(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned long long, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned long long, unsigned long long*, unsigned long long*)
Line
Count
Source
431
14
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
14
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
14
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
14
      auto x{f(args...)};
454
14
      h.action_on_success();
455
14
      return x;
456
14
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
8
    } catch (const StatusException& e) {
466
8
      h.action(e.extract_status());
467
8
      return TILEDB_ERR;
468
8
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
14
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_subarray_t(tiledb_ctx_handle_t*, tiledb_query_t const*, tiledb_subarray_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t const*, tiledb_subarray_t**)
Line
Count
Source
431
9
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
9
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
9
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
9
      auto x{f(args...)};
454
9
      h.action_on_success();
455
9
      return x;
456
9
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
9
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_relevant_fragment_num(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned long long*)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_alloc(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_subarray_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_subarray_t**)
Line
Count
Source
431
4.22k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4.22k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4.22k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4.22k
      auto x{f(args...)};
454
4.22k
      h.action_on_success();
455
4.22k
      return x;
456
4.22k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4.22k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_set_config(tiledb_ctx_handle_t*, tiledb_subarray_t*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_subarray_t*, tiledb_config_handle_t*)
Line
Count
Source
431
9
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
9
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
9
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
9
      auto x{f(args...)};
454
9
      h.action_on_success();
455
9
      return x;
456
9
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
9
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_subarray_free(tiledb_subarray_t**))>::function_from_void(tiledb_subarray_t**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_subarray_t**)
Line
Count
Source
431
4.22k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4.22k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4.22k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4.22k
      auto x{f(args...)};
454
4.22k
      h.action_on_success();
455
4.22k
      return x;
456
4.22k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4.22k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_set_coalesce_ranges(tiledb_ctx_handle_t*, tiledb_subarray_t*, int)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_subarray_t*, int)
Line
Count
Source
431
4.21k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4.21k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4.21k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4.21k
      auto x{f(args...)};
454
4.21k
      h.action_on_success();
455
4.21k
      return x;
456
4.21k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4.21k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_set_subarray(tiledb_ctx_handle_t*, tiledb_subarray_t*, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_subarray_t*, void const*)
Line
Count
Source
431
16
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
16
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
16
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
16
      auto x{f(args...)};
454
16
      h.action_on_success();
455
16
      return x;
456
16
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
6
    } catch (const StatusException& e) {
466
6
      h.action(e.extract_status());
467
6
      return TILEDB_ERR;
468
6
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
16
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_add_range(tiledb_ctx_handle_t*, tiledb_subarray_t*, unsigned int, void const*, void const*, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_subarray_t*, unsigned int, void const*, void const*, void const*)
Line
Count
Source
431
1.01k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
1.01k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
1.01k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
1.01k
      auto x{f(args...)};
454
1.01k
      h.action_on_success();
455
1.01k
      return x;
456
1.01k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
24
    } catch (const StatusException& e) {
466
24
      h.action(e.extract_status());
467
24
      return TILEDB_ERR;
468
24
    } catch (const std::exception& e) {
469
5
      h.action(exception_to_status(e));
470
5
      return TILEDB_ERR;
471
5
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
1.01k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_add_point_ranges(tiledb_ctx_handle_t*, tiledb_subarray_t*, unsigned int, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_subarray_t*, unsigned int, void const*, unsigned long long)
Line
Count
Source
431
4
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4
      auto x{f(args...)};
454
4
      h.action_on_success();
455
4
      return x;
456
4
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_add_range_by_name(tiledb_ctx_handle_t*, tiledb_subarray_t*, char const*, void const*, void const*, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_subarray_t*, char const*, void const*, void const*, void const*)
Line
Count
Source
431
2.97k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2.97k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2.97k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2.97k
      auto x{f(args...)};
454
2.97k
      h.action_on_success();
455
2.97k
      return x;
456
2.97k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2.97k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_add_range_var(tiledb_ctx_handle_t*, tiledb_subarray_t*, unsigned int, void const*, unsigned long long, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_subarray_t*, unsigned int, void const*, unsigned long long, void const*, unsigned long long)
Line
Count
Source
431
230
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
230
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
230
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
230
      auto x{f(args...)};
454
230
      h.action_on_success();
455
230
      return x;
456
230
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
20
    } catch (const StatusException& e) {
466
20
      h.action(e.extract_status());
467
20
      return TILEDB_ERR;
468
20
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
230
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_add_range_var_by_name(tiledb_ctx_handle_t*, tiledb_subarray_t*, char const*, void const*, unsigned long long, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_subarray_t*, char const*, void const*, unsigned long long, void const*, unsigned long long)
Line
Count
Source
431
141
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
141
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
141
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
141
      auto x{f(args...)};
454
141
      h.action_on_success();
455
141
      return x;
456
141
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
141
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_get_range_num(tiledb_ctx_handle_t*, tiledb_subarray_t const*, unsigned int, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_subarray_t const*, unsigned int, unsigned long long*)
Line
Count
Source
431
139
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
139
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
139
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
139
      auto x{f(args...)};
454
139
      h.action_on_success();
455
139
      return x;
456
139
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
2
    } catch (const StatusException& e) {
466
2
      h.action(e.extract_status());
467
2
      return TILEDB_ERR;
468
2
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
139
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_get_range_num_from_name(tiledb_ctx_handle_t*, tiledb_subarray_t const*, char const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_subarray_t const*, char const*, unsigned long long*)
Line
Count
Source
431
4
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4
      auto x{f(args...)};
454
4
      h.action_on_success();
455
4
      return x;
456
4
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_get_range(tiledb_ctx_handle_t*, tiledb_subarray_t const*, unsigned int, unsigned long long, void const**, void const**, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_subarray_t const*, unsigned int, unsigned long long, void const**, void const**, void const**)
Line
Count
Source
431
70
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
70
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
70
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
70
      auto x{f(args...)};
454
70
      h.action_on_success();
455
70
      return x;
456
70
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
10
    } catch (const StatusException& e) {
466
10
      h.action(e.extract_status());
467
10
      return TILEDB_ERR;
468
10
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
70
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_get_range_var_size(tiledb_ctx_handle_t*, tiledb_subarray_t const*, unsigned int, unsigned long long, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_subarray_t const*, unsigned int, unsigned long long, unsigned long long*, unsigned long long*)
Line
Count
Source
431
172
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
172
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
172
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
172
      auto x{f(args...)};
454
172
      h.action_on_success();
455
172
      return x;
456
172
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
84
    } catch (const StatusException& e) {
466
84
      h.action(e.extract_status());
467
84
      return TILEDB_ERR;
468
84
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
172
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_get_range_from_name(tiledb_ctx_handle_t*, tiledb_subarray_t const*, char const*, unsigned long long, void const**, void const**, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_subarray_t const*, char const*, unsigned long long, void const**, void const**, void const**)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_get_range_var_size_from_name(tiledb_ctx_handle_t*, tiledb_subarray_t const*, char const*, unsigned long long, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_subarray_t const*, char const*, unsigned long long, unsigned long long*, unsigned long long*)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_get_range_var(tiledb_ctx_handle_t*, tiledb_subarray_t const*, unsigned int, unsigned long long, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_subarray_t const*, unsigned int, unsigned long long, void*, void*)
Line
Count
Source
431
172
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
172
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
172
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
172
      auto x{f(args...)};
454
172
      h.action_on_success();
455
172
      return x;
456
172
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
84
    } catch (const StatusException& e) {
466
84
      h.action(e.extract_status());
467
84
      return TILEDB_ERR;
468
84
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
172
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_subarray_get_range_var_from_name(tiledb_ctx_handle_t*, tiledb_subarray_t const*, char const*, unsigned long long, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_subarray_t const*, char const*, unsigned long long, void*, void*)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_condition_alloc(tiledb_ctx_handle_t*, tiledb_query_condition_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_condition_t**)
Line
Count
Source
431
7.00k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
7.00k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
7.00k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
7.00k
      auto x{f(args...)};
454
7.00k
      h.action_on_success();
455
7.00k
      return x;
456
7.00k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
7.00k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_query_condition_free(tiledb_query_condition_t**))>::function_from_void(tiledb_query_condition_t**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_query_condition_t**)
Line
Count
Source
431
9.35k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
9.35k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
9.35k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
9.35k
      auto x{f(args...)};
454
9.35k
      h.action_on_success();
455
9.35k
      return x;
456
9.35k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
9.35k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_condition_init(tiledb_ctx_handle_t*, tiledb_query_condition_t*, char const*, void const*, unsigned long long, tiledb_query_condition_op_t)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_condition_t*, char const*, void const*, unsigned long long, tiledb_query_condition_op_t)
Line
Count
Source
431
7.00k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
7.00k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
7.00k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
7.00k
      auto x{f(args...)};
454
7.00k
      h.action_on_success();
455
7.00k
      return x;
456
7.00k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
7.00k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_condition_combine(tiledb_ctx_handle_t*, tiledb_query_condition_t const*, tiledb_query_condition_t const*, tiledb_query_condition_combination_op_t, tiledb_query_condition_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_condition_t const*, tiledb_query_condition_t const*, tiledb_query_condition_combination_op_t, tiledb_query_condition_t**)
Line
Count
Source
431
1.82k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
1.82k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
1.82k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
1.82k
      auto x{f(args...)};
454
1.82k
      h.action_on_success();
455
1.82k
      return x;
456
1.82k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
1.82k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_add_update_value(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void const*, unsigned long long)
Line
Count
Source
431
15
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
15
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
15
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
15
      auto x{f(args...)};
454
15
      h.action_on_success();
455
15
      return x;
456
15
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
15
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_alloc(tiledb_ctx_handle_t*, char const*, tiledb_array_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, tiledb_array_t**)
Line
Count
Source
431
28.6k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
28.6k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
28.6k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
28.6k
      auto x{f(args...)};
454
28.6k
      h.action_on_success();
455
28.6k
      return x;
456
28.6k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
28.6k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_set_open_timestamp_start(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long)
Line
Count
Source
431
161
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
161
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
161
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
161
      auto x{f(args...)};
454
161
      h.action_on_success();
455
161
      return x;
456
161
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
161
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_set_open_timestamp_end(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long)
Line
Count
Source
431
529
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
529
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
529
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
529
      auto x{f(args...)};
454
529
      h.action_on_success();
455
529
      return x;
456
529
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
529
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_open_timestamp_start(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long*)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_open_timestamp_end(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long*)
Line
Count
Source
431
28
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
28
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
28
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
28
      auto x{f(args...)};
454
28
      h.action_on_success();
455
28
      return x;
456
28
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
28
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_delete_array(tiledb_ctx_handle_t*, tiledb_array_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, char const*)
Line
Count
Source
431
4
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4
      auto x{f(args...)};
454
4
      h.action_on_success();
455
4
      return x;
456
4
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_delete_fragments(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, unsigned long long, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, char const*, unsigned long long, unsigned long long)
Line
Count
Source
431
5
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
5
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
5
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
5
      auto x{f(args...)};
454
5
      h.action_on_success();
455
5
      return x;
456
5
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
5
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_open(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t)
Line
Count
Source
431
24.5k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
24.5k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
24.5k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
24.5k
      auto x{f(args...)};
454
24.5k
      h.action_on_success();
455
24.5k
      return x;
456
24.5k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
18
    } catch (const StatusException& e) {
466
18
      h.action(e.extract_status());
467
18
      return TILEDB_ERR;
468
18
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
24.5k
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_open_at(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t, unsigned long long)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_open_with_key(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t, tiledb_encryption_type_t, void const*, unsigned int)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t, tiledb_encryption_type_t, void const*, unsigned int)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_open_at_with_key(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t, tiledb_encryption_type_t, void const*, unsigned int, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t, tiledb_encryption_type_t, void const*, unsigned int, unsigned long long)
Line
Count
Source
431
4.19k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4.19k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4.19k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4.19k
      auto x{f(args...)};
454
4.19k
      h.action_on_success();
455
4.19k
      return x;
456
4.19k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4.19k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_is_open(tiledb_ctx_handle_t*, tiledb_array_t*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, int*)
Line
Count
Source
431
15.0k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
15.0k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
15.0k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
15.0k
      auto x{f(args...)};
454
15.0k
      h.action_on_success();
455
15.0k
      return x;
456
15.0k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
15.0k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_reopen(tiledb_ctx_handle_t*, tiledb_array_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*)
Line
Count
Source
431
168
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
168
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
168
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
168
      auto x{f(args...)};
454
168
      h.action_on_success();
455
168
      return x;
456
168
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
2
    } catch (const StatusException& e) {
466
2
      h.action(e.extract_status());
467
2
      return TILEDB_ERR;
468
2
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
168
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_reopen_at(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_timestamp(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long*)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_set_config(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_config_handle_t*)
Line
Count
Source
431
5.46k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
5.46k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
5.46k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
5.46k
      auto x{f(args...)};
454
5.46k
      h.action_on_success();
455
5.46k
      return x;
456
5.46k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
5.46k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_config(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_config_handle_t**)
Line
Count
Source
431
5
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
5
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
5
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
5
      auto x{f(args...)};
454
5
      h.action_on_success();
455
5
      return x;
456
5
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
5
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_close(tiledb_ctx_handle_t*, tiledb_array_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*)
Line
Count
Source
431
28.7k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
28.7k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
28.7k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
28.7k
      auto x{f(args...)};
454
28.7k
      h.action_on_success();
455
28.7k
      return x;
456
28.7k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
28.7k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_array_free(tiledb_array_t**))>::function_from_void(tiledb_array_t**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_array_t**)
Line
Count
Source
431
28.7k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
28.7k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
28.7k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
28.7k
      auto x{f(args...)};
454
28.7k
      h.action_on_success();
455
28.7k
      return x;
456
28.7k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
28.7k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_schema(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_array_schema_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_array_schema_t**)
Line
Count
Source
431
33.9k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
33.9k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
33.9k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
33.9k
      auto x{f(args...)};
454
33.9k
      h.action_on_success();
455
33.9k
      return x;
456
33.9k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
33.9k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_query_type(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t*)
Line
Count
Source
431
5.83k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
5.83k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
5.83k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
5.83k
      auto x{f(args...)};
454
5.83k
      h.action_on_success();
455
5.83k
      return x;
456
5.83k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
5.83k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_create(tiledb_ctx_handle_t*, char const*, tiledb_array_schema_t const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, tiledb_array_schema_t const*)
Line
Count
Source
431
9.38k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
9.38k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
9.38k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
9.38k
      auto x{f(args...)};
454
9.38k
      h.action_on_success();
455
9.38k
      return x;
456
9.38k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
8
    } catch (const StatusException& e) {
466
8
      h.action(e.extract_status());
467
8
      return TILEDB_ERR;
468
8
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
9.38k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_create_with_key(tiledb_ctx_handle_t*, char const*, tiledb_array_schema_t const*, tiledb_encryption_type_t, void const*, unsigned int)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, tiledb_array_schema_t const*, tiledb_encryption_type_t, void const*, unsigned int)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_consolidate(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)
Line
Count
Source
431
968
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
968
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
968
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
968
      auto x{f(args...)};
454
968
      h.action_on_success();
455
968
      return x;
456
968
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
3
    } catch (const StatusException& e) {
466
3
      h.action(e.extract_status());
467
3
      return TILEDB_ERR;
468
5
    } catch (const std::exception& e) {
469
5
      h.action(exception_to_status(e));
470
5
      return TILEDB_ERR;
471
5
    } catch (...) {
472
1
      h.action(CAPIStatusError(
473
1
          "TileDB Internal: unknown exception type; no further information"));
474
1
      return TILEDB_ERR;
475
1
    }
476
968
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_consolidate_with_key(tiledb_ctx_handle_t*, char const*, tiledb_encryption_type_t, void const*, unsigned int, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, tiledb_encryption_type_t, void const*, unsigned int, tiledb_config_handle_t*)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_consolidate_fragments(tiledb_ctx_handle_t*, char const*, char const**, unsigned long long, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, char const**, unsigned long long, tiledb_config_handle_t*)
Line
Count
Source
431
3
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
3
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
3
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
3
      auto x{f(args...)};
454
3
      h.action_on_success();
455
3
      return x;
456
3
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
3
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_vacuum(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)
Line
Count
Source
431
514
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
514
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
514
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
514
      auto x{f(args...)};
454
514
      h.action_on_success();
455
514
      return x;
456
514
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
1
      h.action(exception_to_status(e));
470
1
      return TILEDB_ERR;
471
1
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
514
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_non_empty_domain(tiledb_ctx_handle_t*, tiledb_array_t*, void*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, void*, int*)
Line
Count
Source
431
13
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
13
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
13
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
13
      auto x{f(args...)};
454
13
      h.action_on_success();
455
13
      return x;
456
13
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
5
    } catch (const StatusException& e) {
466
5
      h.action(e.extract_status());
467
5
      return TILEDB_ERR;
468
5
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
13
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_non_empty_domain_from_index(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned int, void*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, unsigned int, void*, int*)
Line
Count
Source
431
195
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
195
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
195
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
195
      auto x{f(args...)};
454
195
      h.action_on_success();
455
195
      return x;
456
195
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
15
    } catch (const StatusException& e) {
466
15
      h.action(e.extract_status());
467
15
      return TILEDB_ERR;
468
15
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
195
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_non_empty_domain_from_name(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, void*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, char const*, void*, int*)
Line
Count
Source
431
76
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
76
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
76
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
76
      auto x{f(args...)};
454
76
      h.action_on_success();
455
76
      return x;
456
76
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
15
    } catch (const StatusException& e) {
466
15
      h.action(e.extract_status());
467
15
      return TILEDB_ERR;
468
15
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
76
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_non_empty_domain_var_size_from_index(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned int, unsigned long long*, unsigned long long*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, unsigned int, unsigned long long*, unsigned long long*, int*)
Line
Count
Source
431
166
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
166
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
166
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
166
      auto x{f(args...)};
454
166
      h.action_on_success();
455
166
      return x;
456
166
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
14
    } catch (const StatusException& e) {
466
14
      h.action(e.extract_status());
467
14
      return TILEDB_ERR;
468
14
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
166
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_non_empty_domain_var_size_from_name(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, unsigned long long*, unsigned long long*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, char const*, unsigned long long*, unsigned long long*, int*)
Line
Count
Source
431
72
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
72
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
72
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
72
      auto x{f(args...)};
454
72
      h.action_on_success();
455
72
      return x;
456
72
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
14
    } catch (const StatusException& e) {
466
14
      h.action(e.extract_status());
467
14
      return TILEDB_ERR;
468
14
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
72
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_non_empty_domain_var_from_index(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned int, void*, void*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, unsigned int, void*, void*, int*)
Line
Count
Source
431
152
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
152
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
152
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
152
      auto x{f(args...)};
454
152
      h.action_on_success();
455
152
      return x;
456
152
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
152
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_non_empty_domain_var_from_name(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, void*, void*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, char const*, void*, void*, int*)
Line
Count
Source
431
58
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
58
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
58
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
58
      auto x{f(args...)};
454
58
      h.action_on_success();
455
58
      return x;
456
58
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
58
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_uri(tiledb_ctx_handle_t*, tiledb_array_t*, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, char const**)
Line
Count
Source
431
114
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
114
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
114
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
114
      auto x{f(args...)};
454
114
      h.action_on_success();
455
114
      return x;
456
114
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
114
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_encryption_type(tiledb_ctx_handle_t*, char const*, tiledb_encryption_type_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, tiledb_encryption_type_t*)
Line
Count
Source
431
11
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
11
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
11
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
11
      auto x{f(args...)};
454
11
      h.action_on_success();
455
11
      return x;
456
11
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
11
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_put_metadata(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, tiledb_datatype_t, unsigned int, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, char const*, tiledb_datatype_t, unsigned int, void const*)
Line
Count
Source
431
96
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
96
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
96
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
96
      auto x{f(args...)};
454
96
      h.action_on_success();
455
96
      return x;
456
96
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
6
    } catch (const StatusException& e) {
466
6
      h.action(e.extract_status());
467
6
      return TILEDB_ERR;
468
6
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
96
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_delete_metadata(tiledb_ctx_handle_t*, tiledb_array_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, char const*)
Line
Count
Source
431
15
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
15
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
15
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
15
      auto x{f(args...)};
454
15
      h.action_on_success();
455
15
      return x;
456
15
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
15
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_metadata(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, tiledb_datatype_t*, unsigned int*, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, char const*, tiledb_datatype_t*, unsigned int*, void const**)
Line
Count
Source
431
64
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
64
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
64
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
64
      auto x{f(args...)};
454
64
      h.action_on_success();
455
64
      return x;
456
64
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
64
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_metadata_num(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long*)
Line
Count
Source
431
23
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
23
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
23
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
23
      auto x{f(args...)};
454
23
      h.action_on_success();
455
23
      return x;
456
23
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
23
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_get_metadata_from_index(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long, char const**, unsigned int*, tiledb_datatype_t*, unsigned int*, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long, char const**, unsigned int*, tiledb_datatype_t*, unsigned int*, void const**)
Line
Count
Source
431
13
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
13
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
13
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
13
      auto x{f(args...)};
454
13
      h.action_on_success();
455
13
      return x;
456
13
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
2
    } catch (const StatusException& e) {
466
2
      h.action(e.extract_status());
467
2
      return TILEDB_ERR;
468
2
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
13
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_has_metadata_key(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, tiledb_datatype_t*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, char const*, tiledb_datatype_t*, int*)
Line
Count
Source
431
6
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
6
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
6
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
6
      auto x{f(args...)};
454
6
      h.action_on_success();
455
6
      return x;
456
6
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
6
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_consolidate_metadata(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_consolidate_metadata_with_key(tiledb_ctx_handle_t*, char const*, tiledb_encryption_type_t, void const*, unsigned int, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, tiledb_encryption_type_t, void const*, unsigned int, tiledb_config_handle_t*)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_evolve(tiledb_ctx_handle_t*, char const*, tiledb_array_schema_evolution_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, tiledb_array_schema_evolution_t*)
Line
Count
Source
431
13
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
13
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
13
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
13
      auto x{f(args...)};
454
13
      h.action_on_success();
455
13
      return x;
456
13
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
13
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_upgrade_version(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)
Line
Count
Source
431
7
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
7
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
7
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
7
      auto x{f(args...)};
454
7
      h.action_on_success();
455
7
      return x;
456
7
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
7
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_object_type(tiledb_ctx_handle_t*, char const*, tiledb_object_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, tiledb_object_t*)
Line
Count
Source
431
473
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
473
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
473
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
473
      auto x{f(args...)};
454
473
      h.action_on_success();
455
473
      return x;
456
473
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
473
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_object_remove(tiledb_ctx_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*)
Line
Count
Source
431
250
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
250
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
250
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
250
      auto x{f(args...)};
454
250
      h.action_on_success();
455
250
      return x;
456
250
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
250
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_object_move(tiledb_ctx_handle_t*, char const*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, char const*)
Line
Count
Source
431
3
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
3
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
3
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
3
      auto x{f(args...)};
454
3
      h.action_on_success();
455
3
      return x;
456
3
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
3
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_object_walk(tiledb_ctx_handle_t*, char const*, tiledb_walk_order_t, int (*)(char const*, tiledb_object_t, void*), void*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, tiledb_walk_order_t, int (*)(char const*, tiledb_object_t, void*), void*)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_object_ls(tiledb_ctx_handle_t*, char const*, int (*)(char const*, tiledb_object_t, void*), void*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, int (*)(char const*, tiledb_object_t, void*), void*)
Line
Count
Source
431
1
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
1
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
1
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
1
      auto x{f(args...)};
454
1
      h.action_on_success();
455
1
      return x;
456
1
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
1
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_alloc(tiledb_ctx_handle_t*, tiledb_config_handle_t*, tiledb_vfs_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_config_handle_t*, tiledb_vfs_t**)
Line
Count
Source
431
5.32k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
5.32k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
5.32k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
5.32k
      auto x{f(args...)};
454
5.32k
      h.action_on_success();
455
5.32k
      return x;
456
5.32k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
5.32k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_vfs_free(tiledb_vfs_t**))>::function_from_void(tiledb_vfs_t**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_vfs_t**)
Line
Count
Source
431
5.32k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
5.32k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
5.32k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
5.32k
      auto x{f(args...)};
454
5.32k
      h.action_on_success();
455
5.32k
      return x;
456
5.32k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
5.32k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_get_config(tiledb_ctx_handle_t*, tiledb_vfs_t*, tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_vfs_t*, tiledb_config_handle_t**)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_create_bucket(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)
Line
Count
Source
431
1
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
1
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
1
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
1
      auto x{f(args...)};
454
1
      h.action_on_success();
455
1
      return x;
456
1
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
1
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_remove_bucket(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_empty_bucket(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_is_empty_bucket(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int*)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_is_bucket(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int*)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_create_dir(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)
Line
Count
Source
431
6.26k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
6.26k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
6.26k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
6.26k
      auto x{f(args...)};
454
6.26k
      h.action_on_success();
455
6.26k
      return x;
456
6.26k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
6.26k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_is_dir(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int*)
Line
Count
Source
431
13.2k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
13.2k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
13.2k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
13.2k
      auto x{f(args...)};
454
13.2k
      h.action_on_success();
455
13.2k
      return x;
456
13.2k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
13.2k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_remove_dir(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)
Line
Count
Source
431
9.25k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
9.25k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
9.25k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
9.25k
      auto x{f(args...)};
454
9.25k
      h.action_on_success();
455
9.25k
      return x;
456
9.25k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
9.25k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_is_file(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int*)
Line
Count
Source
431
185
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
185
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
185
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
185
      auto x{f(args...)};
454
185
      h.action_on_success();
455
185
      return x;
456
185
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
185
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_remove_file(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)
Line
Count
Source
431
82
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
82
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
82
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
82
      auto x{f(args...)};
454
82
      h.action_on_success();
455
82
      return x;
456
82
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
82
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_dir_size(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, unsigned long long*)
Line
Count
Source
431
9
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
9
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
9
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
9
      auto x{f(args...)};
454
9
      h.action_on_success();
455
9
      return x;
456
9
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
9
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_file_size(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, unsigned long long*)
Line
Count
Source
431
94
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
94
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
94
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
94
      auto x{f(args...)};
454
94
      h.action_on_success();
455
94
      return x;
456
94
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
94
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_move_file(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, char const*)
Line
Count
Source
431
4
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4
      auto x{f(args...)};
454
4
      h.action_on_success();
455
4
      return x;
456
4
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_move_dir(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, char const*)
Line
Count
Source
431
8
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
8
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
8
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
8
      auto x{f(args...)};
454
8
      h.action_on_success();
455
8
      return x;
456
8
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
8
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_copy_file(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, char const*)
Line
Count
Source
431
3
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
3
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
3
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
3
      auto x{f(args...)};
454
3
      h.action_on_success();
455
3
      return x;
456
3
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
3
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_copy_dir(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, char const*)
Line
Count
Source
431
9
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
9
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
9
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
9
      auto x{f(args...)};
454
9
      h.action_on_success();
455
9
      return x;
456
9
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
9
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_open(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, tiledb_vfs_mode_t, tiledb_vfs_fh_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, tiledb_vfs_mode_t, tiledb_vfs_fh_t**)
Line
Count
Source
431
91
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
91
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
91
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
91
      auto x{f(args...)};
454
91
      h.action_on_success();
455
91
      return x;
456
91
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
91
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_close(tiledb_ctx_handle_t*, tiledb_vfs_fh_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_vfs_fh_t*)
Line
Count
Source
431
85
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
85
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
85
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
85
      auto x{f(args...)};
454
85
      h.action_on_success();
455
85
      return x;
456
85
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
2
    } catch (const StatusException& e) {
466
2
      h.action(e.extract_status());
467
2
      return TILEDB_ERR;
468
2
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
85
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_read(tiledb_ctx_handle_t*, tiledb_vfs_fh_t*, unsigned long long, void*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_vfs_fh_t*, unsigned long long, void*, unsigned long long)
Line
Count
Source
431
48
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
48
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
48
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
48
      auto x{f(args...)};
454
48
      h.action_on_success();
455
48
      return x;
456
48
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
48
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_write(tiledb_ctx_handle_t*, tiledb_vfs_fh_t*, void const*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_vfs_fh_t*, void const*, unsigned long long)
Line
Count
Source
431
42
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
42
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
42
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
42
      auto x{f(args...)};
454
42
      h.action_on_success();
455
42
      return x;
456
42
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
42
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_sync(tiledb_ctx_handle_t*, tiledb_vfs_fh_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_vfs_fh_t*)
Line
Count
Source
431
6
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
6
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
6
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
6
      auto x{f(args...)};
454
6
      h.action_on_success();
455
6
      return x;
456
6
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
6
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_ls(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int (*)(char const*, void*), void*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int (*)(char const*, void*), void*)
Line
Count
Source
431
498
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
498
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
498
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
498
      auto x{f(args...)};
454
498
      h.action_on_success();
455
498
      return x;
456
498
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
498
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_vfs_fh_free(tiledb_vfs_fh_t**))>::function_from_void(tiledb_vfs_fh_t**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_vfs_fh_t**)
Line
Count
Source
431
86
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
86
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
86
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
86
      auto x{f(args...)};
454
86
      h.action_on_success();
455
86
      return x;
456
86
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
86
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_fh_is_closed(tiledb_ctx_handle_t*, tiledb_vfs_fh_t*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_vfs_fh_t*, int*)
Line
Count
Source
431
16
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
16
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
16
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
16
      auto x{f(args...)};
454
16
      h.action_on_success();
455
16
      return x;
456
16
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
16
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_touch(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)
Line
Count
Source
431
1.06k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
1.06k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
1.06k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
1.06k
      auto x{f(args...)};
454
1.06k
      h.action_on_success();
455
1.06k
      return x;
456
1.06k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
1.06k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_uri_to_path(tiledb_ctx_handle_t*, char const*, char*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, char*, unsigned int*)
Line
Count
Source
431
8
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
8
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
8
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
8
      auto x{f(args...)};
454
8
      h.action_on_success();
455
8
      return x;
456
8
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
8
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_enable()), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&)
Line
Count
Source
431
4
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4
      auto x{f(args...)};
454
4
      h.action_on_success();
455
4
      return x;
456
4
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_disable()), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_reset()), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&)
Line
Count
Source
431
4
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4
      auto x{f(args...)};
454
4
      h.action_on_success();
455
4
      return x;
456
4
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_dump(__sFILE*)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, __sFILE*)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_dump_str(char**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, char**)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_raw_dump(__sFILE*)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, __sFILE*)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_raw_dump_str(char**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, char**)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_free_str(char**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, char**)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_heap_profiler_enable(char const*, unsigned long long, unsigned long long, unsigned long long)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, char const*, unsigned long long, unsigned long long, unsigned long long)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_array(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_array(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_array_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_array_t**)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_array_schema(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)
Line
Count
Source
431
36
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
36
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
36
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
36
      auto x{f(args...)};
454
36
      h.action_on_success();
455
36
      return x;
456
36
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
36
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_array_schema(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_array_schema_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_array_schema_t**)
Line
Count
Source
431
37
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
37
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
37
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
37
      auto x{f(args...)};
454
37
      h.action_on_success();
455
37
      return x;
456
37
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
37
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_array_open(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)
Line
Count
Source
431
1
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
1
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
1
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
1
      auto x{f(args...)};
454
1
      h.action_on_success();
455
1
      return x;
456
1
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
1
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_array_open(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_array_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_array_t**)
Line
Count
Source
431
1
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
1
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
1
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
1
      auto x{f(args...)};
454
1
      h.action_on_success();
455
1
      return x;
456
1
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
1
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_array_schema_evolution(tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)
Line
Count
Source
431
3
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
3
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
3
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
3
      auto x{f(args...)};
454
3
      h.action_on_success();
455
3
      return x;
456
3
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
3
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_array_schema_evolution(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_array_schema_evolution_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_array_schema_evolution_t**)
Line
Count
Source
431
3
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
3
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
3
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
3
      auto x{f(args...)};
454
3
      h.action_on_success();
455
3
      return x;
456
3
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
3
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_query(tiledb_ctx_handle_t*, tiledb_query_t const*, tiledb_serialization_type_t, int, tiledb_buffer_list_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t const*, tiledb_serialization_type_t, int, tiledb_buffer_list_t**)
Line
Count
Source
431
2.42k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2.42k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2.42k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2.42k
      auto x{f(args...)};
454
2.42k
      h.action_on_success();
455
2.42k
      return x;
456
2.42k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2.42k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_query(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_query_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_query_t*)
Line
Count
Source
431
2.42k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2.42k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2.42k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2.42k
      auto x{f(args...)};
454
2.42k
      h.action_on_success();
455
2.42k
      return x;
456
2.42k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2.42k
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_array_nonempty_domain(tiledb_ctx_handle_t*, tiledb_array_t const*, void const*, int, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t const*, void const*, int, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_array_nonempty_domain(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, void*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, void*, int*)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_array_non_empty_domain_all_dimensions(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)
Line
Count
Source
431
36
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
36
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
36
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
36
      auto x{f(args...)};
454
36
      h.action_on_success();
455
36
      return x;
456
36
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
36
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_array_non_empty_domain_all_dimensions(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int)
Line
Count
Source
431
36
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
36
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
36
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
36
      auto x{f(args...)};
454
36
      h.action_on_success();
455
36
      return x;
456
36
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
36
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_array_max_buffer_sizes(tiledb_ctx_handle_t*, tiledb_array_t const*, void const*, tiledb_serialization_type_t, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t const*, void const*, tiledb_serialization_type_t, tiledb_buffer_handle_t**)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_array_metadata(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_serialization_type_t, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_serialization_type_t, tiledb_buffer_handle_t**)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_array_metadata(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_serialization_type_t, tiledb_buffer_handle_t const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_serialization_type_t, tiledb_buffer_handle_t const*)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_query_est_result_sizes(tiledb_ctx_handle_t*, tiledb_query_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)
Line
Count
Source
431
32
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
32
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
32
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
32
      auto x{f(args...)};
454
32
      h.action_on_success();
455
32
      return x;
456
32
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
32
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_query_est_result_sizes(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t const*)
Line
Count
Source
431
32
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
32
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
32
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
32
      auto x{f(args...)};
454
32
      h.action_on_success();
455
32
      return x;
456
32
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
32
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_config(tiledb_ctx_handle_t*, tiledb_config_handle_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_config_handle_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_config(tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_config_handle_t**)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_fragment_info_request(tiledb_ctx_handle_t*, tiledb_fragment_info_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_fragment_info_request(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_fragment_info_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_fragment_info_t*)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_fragment_info(tiledb_ctx_handle_t*, tiledb_fragment_info_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)
Line
Count
Source
431
38
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
38
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
38
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
38
      auto x{f(args...)};
454
38
      h.action_on_success();
455
38
      return x;
456
38
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
38
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_fragment_info(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, char const*, int, tiledb_fragment_info_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, char const*, int, tiledb_fragment_info_t*)
Line
Count
Source
431
38
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
38
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
38
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
38
      auto x{f(args...)};
454
38
      h.action_on_success();
455
38
      return x;
456
38
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
38
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::impl::tiledb_query_submit_async_func(tiledb_ctx_handle_t*, tiledb_query_t*, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, void*, void*)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_alloc(tiledb_ctx_handle_t*, char const*, tiledb_fragment_info_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, tiledb_fragment_info_t**)
Line
Count
Source
431
111
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
111
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
111
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
111
      auto x{f(args...)};
454
111
      h.action_on_success();
455
111
      return x;
456
111
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
111
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_fragment_info_free(tiledb_fragment_info_t**))>::function_from_void(tiledb_fragment_info_t**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_fragment_info_t**)
Line
Count
Source
431
113
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
113
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
113
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
113
      auto x{f(args...)};
454
113
      h.action_on_success();
455
113
      return x;
456
113
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
113
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_set_config(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, tiledb_config_handle_t*)
Line
Count
Source
431
11
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
11
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
11
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
11
      auto x{f(args...)};
454
11
      h.action_on_success();
455
11
      return x;
456
11
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
11
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_config(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, tiledb_config_handle_t**)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_load(tiledb_ctx_handle_t*, tiledb_fragment_info_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*)
Line
Count
Source
431
101
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
101
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
101
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
101
      auto x{f(args...)};
454
101
      h.action_on_success();
455
101
      return x;
456
101
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
6
    } catch (const StatusException& e) {
466
6
      h.action(e.extract_status());
467
6
      return TILEDB_ERR;
468
6
    } catch (const std::exception& e) {
469
4
      h.action(exception_to_status(e));
470
4
      return TILEDB_ERR;
471
4
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
101
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_load_with_key(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, tiledb_encryption_type_t, void const*, unsigned int)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, tiledb_encryption_type_t, void const*, unsigned int)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_fragment_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const**)
Line
Count
Source
431
6
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
6
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
6
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
6
      auto x{f(args...)};
454
6
      h.action_on_success();
455
6
      return x;
456
6
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
2
    } catch (const StatusException& e) {
466
2
      h.action(e.extract_status());
467
2
      return TILEDB_ERR;
468
2
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
6
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_fragment_num(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int*)
Line
Count
Source
431
24
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
24
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
24
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
24
      auto x{f(args...)};
454
24
      h.action_on_success();
455
24
      return x;
456
24
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
24
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_fragment_uri(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const**)
Line
Count
Source
431
28
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
28
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
28
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
28
      auto x{f(args...)};
454
28
      h.action_on_success();
455
28
      return x;
456
28
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
4
    } catch (const StatusException& e) {
466
4
      h.action(e.extract_status());
467
4
      return TILEDB_ERR;
468
4
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
28
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_fragment_size(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned long long*)
Line
Count
Source
431
6
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
6
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
6
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
6
      auto x{f(args...)};
454
6
      h.action_on_success();
455
6
      return x;
456
6
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
6
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_dense(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, int*)
Line
Count
Source
431
12
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
12
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
12
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
12
      auto x{f(args...)};
454
12
      h.action_on_success();
455
12
      return x;
456
12
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
12
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_sparse(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, int*)
Line
Count
Source
431
12
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
12
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
12
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
12
      auto x{f(args...)};
454
12
      h.action_on_success();
455
12
      return x;
456
12
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
12
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_timestamp_range(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned long long*, unsigned long long*)
Line
Count
Source
431
6
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
6
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
6
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
6
      auto x{f(args...)};
454
6
      h.action_on_success();
455
6
      return x;
456
6
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
6
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_non_empty_domain_from_index(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, void*)
Line
Count
Source
431
96
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
96
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
96
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
96
      auto x{f(args...)};
454
96
      h.action_on_success();
455
96
      return x;
456
96
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
6
    } catch (const StatusException& e) {
466
6
      h.action(e.extract_status());
467
6
      return TILEDB_ERR;
468
6
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
96
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_non_empty_domain_from_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const*, void*)
Line
Count
Source
431
12
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
12
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
12
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
12
      auto x{f(args...)};
454
12
      h.action_on_success();
455
12
      return x;
456
12
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
6
    } catch (const StatusException& e) {
466
6
      h.action(e.extract_status());
467
6
      return TILEDB_ERR;
468
6
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
12
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_non_empty_domain_var_size_from_index(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, unsigned long long*, unsigned long long*)
Line
Count
Source
431
10
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
10
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
10
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
10
      auto x{f(args...)};
454
10
      h.action_on_success();
455
10
      return x;
456
10
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
6
    } catch (const StatusException& e) {
466
6
      h.action(e.extract_status());
467
6
      return TILEDB_ERR;
468
6
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
10
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_non_empty_domain_var_size_from_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const*, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const*, unsigned long long*, unsigned long long*)
Line
Count
Source
431
10
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
10
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
10
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
10
      auto x{f(args...)};
454
10
      h.action_on_success();
455
10
      return x;
456
10
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
6
    } catch (const StatusException& e) {
466
6
      h.action(e.extract_status());
467
6
      return TILEDB_ERR;
468
6
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
10
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_non_empty_domain_var_from_index(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, void*, void*)
Line
Count
Source
431
8
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
8
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
8
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
8
      auto x{f(args...)};
454
8
      h.action_on_success();
455
8
      return x;
456
8
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
4
    } catch (const StatusException& e) {
466
4
      h.action(e.extract_status());
467
4
      return TILEDB_ERR;
468
4
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
8
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_non_empty_domain_var_from_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const*, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const*, void*, void*)
Line
Count
Source
431
8
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
8
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
8
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
8
      auto x{f(args...)};
454
8
      h.action_on_success();
455
8
      return x;
456
8
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
4
    } catch (const StatusException& e) {
466
4
      h.action(e.extract_status());
467
4
      return TILEDB_ERR;
468
4
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
8
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_mbr_num(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned long long*)
Line
Count
Source
431
32
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
32
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
32
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
32
      auto x{f(args...)};
454
32
      h.action_on_success();
455
32
      return x;
456
32
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
4
    } catch (const StatusException& e) {
466
4
      h.action(e.extract_status());
467
4
      return TILEDB_ERR;
468
4
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
32
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_mbr_from_index(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, unsigned int, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, unsigned int, void*)
Line
Count
Source
431
14
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
14
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
14
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
14
      auto x{f(args...)};
454
14
      h.action_on_success();
455
14
      return x;
456
14
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
10
    } catch (const StatusException& e) {
466
10
      h.action(e.extract_status());
467
10
      return TILEDB_ERR;
468
10
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
14
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_mbr_from_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, char const*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, char const*, void*)
Line
Count
Source
431
14
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
14
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
14
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
14
      auto x{f(args...)};
454
14
      h.action_on_success();
455
14
      return x;
456
14
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
10
    } catch (const StatusException& e) {
466
10
      h.action(e.extract_status());
467
10
      return TILEDB_ERR;
468
10
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
14
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_mbr_var_size_from_index(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, unsigned int, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, unsigned int, unsigned long long*, unsigned long long*)
Line
Count
Source
431
4
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4
      auto x{f(args...)};
454
4
      h.action_on_success();
455
4
      return x;
456
4
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_mbr_var_size_from_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, char const*, unsigned long long*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, char const*, unsigned long long*, unsigned long long*)
Line
Count
Source
431
4
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4
      auto x{f(args...)};
454
4
      h.action_on_success();
455
4
      return x;
456
4
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_mbr_var_from_index(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, unsigned int, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, unsigned int, void*, void*)
Line
Count
Source
431
4
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4
      auto x{f(args...)};
454
4
      h.action_on_success();
455
4
      return x;
456
4
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_mbr_var_from_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, char const*, void*, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, char const*, void*, void*)
Line
Count
Source
431
4
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4
      auto x{f(args...)};
454
4
      h.action_on_success();
455
4
      return x;
456
4
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_cell_num(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned long long*)
Line
Count
Source
431
20
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
20
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
20
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
20
      auto x{f(args...)};
454
20
      h.action_on_success();
455
20
      return x;
456
20
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
20
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_total_cell_num(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned long long*)
Line
Count
Source
431
8
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
8
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
8
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
8
      auto x{f(args...)};
454
8
      h.action_on_success();
455
8
      return x;
456
8
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
8
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_version(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int*)
Line
Count
Source
431
14
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
14
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
14
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
14
      auto x{f(args...)};
454
14
      h.action_on_success();
455
14
      return x;
456
14
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
14
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_has_consolidated_metadata(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, int*)
Line
Count
Source
431
50
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
50
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
50
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
50
      auto x{f(args...)};
454
50
      h.action_on_success();
455
50
      return x;
456
50
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
6
    } catch (const StatusException& e) {
466
6
      h.action(e.extract_status());
467
6
      return TILEDB_ERR;
468
6
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
50
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_unconsolidated_metadata_num(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int*)
Line
Count
Source
431
20
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
20
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
20
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
20
      auto x{f(args...)};
454
20
      h.action_on_success();
455
20
      return x;
456
20
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
20
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_to_vacuum_num(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int*)
Line
Count
Source
431
22
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
22
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
22
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
22
      auto x{f(args...)};
454
22
      h.action_on_success();
455
22
      return x;
456
22
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
22
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_to_vacuum_uri(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const**)
Line
Count
Source
431
8
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
8
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
8
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
8
      auto x{f(args...)};
454
8
      h.action_on_success();
455
8
      return x;
456
8
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
4
    } catch (const StatusException& e) {
466
4
      h.action(e.extract_status());
467
4
      return TILEDB_ERR;
468
4
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
8
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_array_schema(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, tiledb_array_schema_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, tiledb_array_schema_t**)
Line
Count
Source
431
12
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
12
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
12
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
12
      auto x{f(args...)};
454
12
      h.action_on_success();
455
12
      return x;
456
12
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
12
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_get_array_schema_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const**)
Line
Count
Source
431
4
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4
      auto x{f(args...)};
454
4
      h.action_on_success();
455
4
      return x;
456
4
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_fragment_info_dump(tiledb_ctx_handle_t*, tiledb_fragment_info_t const*, __sFILE*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_fragment_info_t const*, __sFILE*)
Line
Count
Source
431
8
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
8
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
8
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
8
      auto x{f(args...)};
454
8
      h.action_on_success();
455
8
      return x;
456
8
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
8
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_get_status_details(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_experimental_query_status_details_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_experimental_query_status_details_t*)
Line
Count
Source
431
56
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
56
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
56
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
56
      auto x{f(args...)};
454
56
      h.action_on_success();
455
56
      return x;
456
56
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
56
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_consolidation_plan_create_with_mbr(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long, tiledb_consolidation_plan_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long, tiledb_consolidation_plan_t**)
Line
Count
Source
431
12
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
12
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
12
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
12
      auto x{f(args...)};
454
12
      h.action_on_success();
455
12
      return x;
456
12
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
12
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_consolidation_plan_free(tiledb_consolidation_plan_t**))>::function_from_void(tiledb_consolidation_plan_t**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_consolidation_plan_t**)
Line
Count
Source
431
12
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
12
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
12
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
12
      auto x{f(args...)};
454
12
      h.action_on_success();
455
12
      return x;
456
12
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
12
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_consolidation_plan_get_num_nodes(tiledb_ctx_handle_t*, tiledb_consolidation_plan_t*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_consolidation_plan_t*, unsigned long long*)
Line
Count
Source
431
30
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
30
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
30
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
30
      auto x{f(args...)};
454
30
      h.action_on_success();
455
30
      return x;
456
30
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
30
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_consolidation_plan_get_num_fragments(tiledb_ctx_handle_t*, tiledb_consolidation_plan_t*, unsigned long long, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_consolidation_plan_t*, unsigned long long, unsigned long long*)
Line
Count
Source
431
116
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
116
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
116
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
116
      auto x{f(args...)};
454
116
      h.action_on_success();
455
116
      return x;
456
116
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
116
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_consolidation_plan_get_fragment_uri(tiledb_ctx_handle_t*, tiledb_consolidation_plan_t*, unsigned long long, unsigned long long, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_consolidation_plan_t*, unsigned long long, unsigned long long, char const**)
Line
Count
Source
431
24
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
24
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
24
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
24
      auto x{f(args...)};
454
24
      h.action_on_success();
455
24
      return x;
456
24
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
24
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_consolidation_plan_dump_json_str(tiledb_ctx_handle_t*, tiledb_consolidation_plan_t const*, char**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_consolidation_plan_t const*, char**)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_consolidation_plan_free_json_str(char**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, char**)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::common::detail::tiledb_filestore_schema_create(tiledb_ctx_handle_t*, char const*, tiledb_array_schema_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, tiledb_array_schema_t**)
Line
Count
Source
431
8
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
8
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
8
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
8
      auto x{f(args...)};
454
8
      h.action_on_success();
455
8
      return x;
456
8
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
8
  };
tiledb::api::CAPIFunction<&(tiledb::common::detail::tiledb_filestore_uri_import(tiledb_ctx_handle_t*, char const*, char const*, tiledb_mime_type_t)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, char const*, tiledb_mime_type_t)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::common::detail::tiledb_filestore_uri_export(tiledb_ctx_handle_t*, char const*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, char const*)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
1
      h.action(exception_to_status(e));
470
1
      return TILEDB_ERR;
471
1
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::common::detail::tiledb_filestore_buffer_import(tiledb_ctx_handle_t*, char const*, void*, unsigned long, tiledb_mime_type_t)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, void*, unsigned long, tiledb_mime_type_t)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::common::detail::tiledb_filestore_buffer_export(tiledb_ctx_handle_t*, char const*, unsigned long, void*, unsigned long)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, unsigned long, void*, unsigned long)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::common::detail::tiledb_filestore_size(tiledb_ctx_handle_t*, char const*, unsigned long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, unsigned long*)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::common::detail::tiledb_mime_type_to_str(tiledb_mime_type_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_mime_type_t, char const**)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::common::detail::tiledb_mime_type_from_str(char const*, tiledb_mime_type_t*)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, char const*, tiledb_mime_type_t*)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_alloc(tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_buffer_handle_t**)
Line
Count
Source
431
2.42k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2.42k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2.42k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2.42k
      auto x{f(args...)};
454
2.42k
      h.action_on_success();
455
2.42k
      return x;
456
2.42k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2.42k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_buffer_free(tiledb_buffer_handle_t**))>::function_from_void(tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_buffer_handle_t**)
Line
Count
Source
431
5.00k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
5.00k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
5.00k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
5.00k
      auto x{f(args...)};
454
5.00k
      h.action_on_success();
455
5.00k
      return x;
456
5.00k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
5.00k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_set_type(tiledb_buffer_handle_t*, tiledb_datatype_t)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_buffer_handle_t*, tiledb_datatype_t)
Line
Count
Source
431
1
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
1
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
1
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
1
      auto x{f(args...)};
454
1
      h.action_on_success();
455
1
      return x;
456
1
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
1
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_get_type(tiledb_buffer_handle_t const*, tiledb_datatype_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_buffer_handle_t const*, tiledb_datatype_t*)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_get_data(tiledb_buffer_handle_t const*, void**, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_buffer_handle_t const*, void**, unsigned long long*)
Line
Count
Source
431
2.42k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2.42k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2.42k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2.42k
      auto x{f(args...)};
454
2.42k
      h.action_on_success();
455
2.42k
      return x;
456
2.42k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2.42k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_set_data(tiledb_buffer_handle_t*, void*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_buffer_handle_t*, void*, unsigned long long)
Line
Count
Source
431
2.42k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2.42k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2.42k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2.42k
      auto x{f(args...)};
454
2.42k
      h.action_on_success();
455
2.42k
      return x;
456
2.42k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2.42k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_error_message(tiledb_error_handle_t*, char const**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_error_handle_t*, char const**)
Line
Count
Source
431
270
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
270
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
270
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
270
      auto x{f(args...)};
454
270
      h.action_on_success();
455
270
      return x;
456
270
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
2
    } catch (const StatusException& e) {
466
2
      h.action(e.extract_status());
467
2
      return TILEDB_ERR;
468
2
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
270
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_error_free(tiledb_error_handle_t**))>::function_from_void(tiledb_error_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_error_handle_t**)
Line
Count
Source
431
290
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
290
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
290
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
290
      auto x{f(args...)};
454
290
      h.action_on_success();
455
290
      return x;
456
290
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
10
    } catch (const StatusException& e) {
466
10
      h.action(e.extract_status());
467
10
      return TILEDB_ERR;
468
10
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
290
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_alloc(tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailErr>::function(tiledb::api::detail::ExceptionActionDetailErr&, tiledb_config_handle_t**)
Line
Count
Source
431
16.8k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
16.8k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
16.8k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
16.8k
      auto x{f(args...)};
454
16.8k
      h.action_on_success();
455
16.8k
      return x;
456
16.8k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
1
    } catch (const detail::InvalidErrorException& e) {
463
1
      h.action(exception_to_status(e));
464
1
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
16.8k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_config_free(tiledb_config_handle_t**))>::function_from_void(tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_config_handle_t**)
Line
Count
Source
431
17.6k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
17.6k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
17.6k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
17.6k
      auto x{f(args...)};
454
17.6k
      h.action_on_success();
455
17.6k
      return x;
456
17.6k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
11
    } catch (const StatusException& e) {
466
11
      h.action(e.extract_status());
467
11
      return TILEDB_ERR;
468
11
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
17.6k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_set(tiledb_config_handle_t*, char const*, char const*)), tiledb::api::detail::ExceptionActionDetailErr>::function(tiledb::api::detail::ExceptionActionDetailErr&, tiledb_config_handle_t*, char const*, char const*)
Line
Count
Source
431
21.8k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
21.8k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
21.8k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
21.8k
      auto x{f(args...)};
454
21.8k
      h.action_on_success();
455
21.8k
      return x;
456
21.8k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
1
    } catch (const detail::InvalidErrorException& e) {
463
1
      h.action(exception_to_status(e));
464
1
      return TILEDB_INVALID_ERROR;
465
16
    } catch (const StatusException& e) {
466
16
      h.action(e.extract_status());
467
16
      return TILEDB_ERR;
468
16
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
21.8k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_get(tiledb_config_handle_t*, char const*, char const**)), tiledb::api::detail::ExceptionActionDetailErr>::function(tiledb::api::detail::ExceptionActionDetailErr&, tiledb_config_handle_t*, char const*, char const**)
Line
Count
Source
431
137
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
137
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
137
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
137
      auto x{f(args...)};
454
137
      h.action_on_success();
455
137
      return x;
456
137
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
1
    } catch (const detail::InvalidErrorException& e) {
463
1
      h.action(exception_to_status(e));
464
1
      return TILEDB_INVALID_ERROR;
465
3
    } catch (const StatusException& e) {
466
3
      h.action(e.extract_status());
467
3
      return TILEDB_ERR;
468
3
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
137
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_unset(tiledb_config_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailErr>::function(tiledb::api::detail::ExceptionActionDetailErr&, tiledb_config_handle_t*, char const*)
Line
Count
Source
431
8
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
8
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
8
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
8
      auto x{f(args...)};
454
8
      h.action_on_success();
455
8
      return x;
456
8
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
1
    } catch (const detail::InvalidErrorException& e) {
463
1
      h.action(exception_to_status(e));
464
1
      return TILEDB_INVALID_ERROR;
465
2
    } catch (const StatusException& e) {
466
2
      h.action(e.extract_status());
467
2
      return TILEDB_ERR;
468
2
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
8
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_load_from_file(tiledb_config_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailErr>::function(tiledb::api::detail::ExceptionActionDetailErr&, tiledb_config_handle_t*, char const*)
Line
Count
Source
431
7
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
7
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
7
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
7
      auto x{f(args...)};
454
7
      h.action_on_success();
455
7
      return x;
456
7
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
1
    } catch (const detail::InvalidErrorException& e) {
463
1
      h.action(exception_to_status(e));
464
1
      return TILEDB_INVALID_ERROR;
465
5
    } catch (const StatusException& e) {
466
5
      h.action(e.extract_status());
467
5
      return TILEDB_ERR;
468
5
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
7
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_save_to_file(tiledb_config_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailErr>::function(tiledb::api::detail::ExceptionActionDetailErr&, tiledb_config_handle_t*, char const*)
Line
Count
Source
431
4
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4
      auto x{f(args...)};
454
4
      h.action_on_success();
455
4
      return x;
456
4
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
1
    } catch (const detail::InvalidErrorException& e) {
463
1
      h.action(exception_to_status(e));
464
1
      return TILEDB_INVALID_ERROR;
465
2
    } catch (const StatusException& e) {
466
2
      h.action(e.extract_status());
467
2
      return TILEDB_ERR;
468
2
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_compare(tiledb_config_handle_t*, tiledb_config_handle_t*, unsigned char*)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_config_handle_t*, tiledb_config_handle_t*, unsigned char*)
Line
Count
Source
431
12
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
12
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
12
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
12
      auto x{f(args...)};
454
12
      h.action_on_success();
455
12
      return x;
456
12
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
3
    } catch (const StatusException& e) {
466
3
      h.action(e.extract_status());
467
3
      return TILEDB_ERR;
468
3
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
12
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_iter_alloc(tiledb_config_handle_t*, char const*, tiledb_config_iter_handle_t**)), tiledb::api::detail::ExceptionActionDetailErr>::function(tiledb::api::detail::ExceptionActionDetailErr&, tiledb_config_handle_t*, char const*, tiledb_config_iter_handle_t**)
Line
Count
Source
431
29
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
29
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
29
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
29
      auto x{f(args...)};
454
29
      h.action_on_success();
455
29
      return x;
456
29
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
1
    } catch (const detail::InvalidErrorException& e) {
463
1
      h.action(exception_to_status(e));
464
1
      return TILEDB_INVALID_ERROR;
465
2
    } catch (const StatusException& e) {
466
2
      h.action(e.extract_status());
467
2
      return TILEDB_ERR;
468
2
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
29
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_iter_reset(tiledb_config_handle_t*, tiledb_config_iter_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailErr>::function(tiledb::api::detail::ExceptionActionDetailErr&, tiledb_config_handle_t*, tiledb_config_iter_handle_t*, char const*)
Line
Count
Source
431
4
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4
      auto x{f(args...)};
454
4
      h.action_on_success();
455
4
      return x;
456
4
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
1
    } catch (const detail::InvalidErrorException& e) {
463
1
      h.action(exception_to_status(e));
464
1
      return TILEDB_INVALID_ERROR;
465
2
    } catch (const StatusException& e) {
466
2
      h.action(e.extract_status());
467
2
      return TILEDB_ERR;
468
2
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_config_iter_free(tiledb_config_iter_handle_t**))>::function_from_void(tiledb_config_iter_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_config_iter_handle_t**)
Line
Count
Source
431
27
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
27
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
27
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
27
      auto x{f(args...)};
454
27
      h.action_on_success();
455
27
      return x;
456
27
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
27
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_iter_here(tiledb_config_iter_handle_t*, char const**, char const**)), tiledb::api::detail::ExceptionActionDetailErr>::function(tiledb::api::detail::ExceptionActionDetailErr&, tiledb_config_iter_handle_t*, char const**, char const**)
Line
Count
Source
431
421
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
421
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
421
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
421
      auto x{f(args...)};
454
421
      h.action_on_success();
455
421
      return x;
456
421
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
1
    } catch (const detail::InvalidErrorException& e) {
463
1
      h.action(exception_to_status(e));
464
1
      return TILEDB_INVALID_ERROR;
465
3
    } catch (const StatusException& e) {
466
3
      h.action(e.extract_status());
467
3
      return TILEDB_ERR;
468
3
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
421
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_iter_next(tiledb_config_iter_handle_t*)), tiledb::api::detail::ExceptionActionDetailErr>::function(tiledb::api::detail::ExceptionActionDetailErr&, tiledb_config_iter_handle_t*)
Line
Count
Source
431
417
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
417
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
417
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
417
      auto x{f(args...)};
454
417
      h.action_on_success();
455
417
      return x;
456
417
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
1
    } catch (const detail::InvalidErrorException& e) {
463
1
      h.action(exception_to_status(e));
464
1
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
417
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_iter_done(tiledb_config_iter_handle_t*, int*)), tiledb::api::detail::ExceptionActionDetailErr>::function(tiledb::api::detail::ExceptionActionDetailErr&, tiledb_config_iter_handle_t*, int*)
Line
Count
Source
431
427
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
427
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
427
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
427
      auto x{f(args...)};
454
427
      h.action_on_success();
455
427
      return x;
456
427
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
1
    } catch (const detail::InvalidErrorException& e) {
463
1
      h.action(exception_to_status(e));
464
1
      return TILEDB_INVALID_ERROR;
465
2
    } catch (const StatusException& e) {
466
2
      h.action(e.extract_status());
467
2
      return TILEDB_ERR;
468
2
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
427
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_ctx_alloc(tiledb_config_handle_t*, tiledb_ctx_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_config_handle_t*, tiledb_ctx_handle_t**)
Line
Count
Source
431
9.68k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
9.68k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
9.68k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
9.68k
      auto x{f(args...)};
454
9.68k
      h.action_on_success();
455
9.68k
      return x;
456
9.68k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
1
      h.action(exception_to_status(e));
470
1
      return TILEDB_ERR;
471
1
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
9.68k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_ctx_alloc(tiledb_config_handle_t*, tiledb_ctx_handle_t**)), tiledb::api::detail::ExceptionActionDetailErr>::function(tiledb::api::detail::ExceptionActionDetailErr&, tiledb_config_handle_t*, tiledb_ctx_handle_t**)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
1
      h.action(exception_to_status(e));
470
1
      return TILEDB_ERR;
471
1
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_ctx_free(tiledb_ctx_handle_t**))>::function_from_void(tiledb_ctx_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_ctx_handle_t**)
Line
Count
Source
431
9.67k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
9.67k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
9.67k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
9.67k
      auto x{f(args...)};
454
9.67k
      h.action_on_success();
455
9.67k
      return x;
456
9.67k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
2
    } catch (const StatusException& e) {
466
2
      h.action(e.extract_status());
467
2
      return TILEDB_ERR;
468
2
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
9.67k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_ctx_get_stats(tiledb_ctx_handle_t*, char**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char**)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
1
    } catch (const detail::InvalidContextException& e) {
460
1
      h.action(exception_to_status(e));
461
1
      return TILEDB_INVALID_CONTEXT;
462
1
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_ctx_get_config(tiledb_ctx_handle_t*, tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_config_handle_t**)
Line
Count
Source
431
785
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
785
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
785
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
785
      auto x{f(args...)};
454
785
      h.action_on_success();
455
785
      return x;
456
785
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
1
    } catch (const detail::InvalidContextException& e) {
460
1
      h.action(exception_to_status(e));
461
1
      return TILEDB_INVALID_CONTEXT;
462
1
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
785
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_ctx_get_last_error(tiledb_ctx_handle_t*, tiledb_error_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_error_handle_t**)
Line
Count
Source
431
412
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
412
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
412
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
412
      auto x{f(args...)};
454
412
      h.action_on_success();
455
412
      return x;
456
412
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
1
    } catch (const detail::InvalidContextException& e) {
460
1
      h.action(exception_to_status(e));
461
1
      return TILEDB_INVALID_CONTEXT;
462
1
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
412
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_ctx_is_supported_fs(tiledb_ctx_handle_t*, tiledb_filesystem_t, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_filesystem_t, int*)
Line
Count
Source
431
1.95k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
1.95k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
1.95k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
1.95k
      auto x{f(args...)};
454
1.95k
      h.action_on_success();
455
1.95k
      return x;
456
1.95k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
1
    } catch (const detail::InvalidContextException& e) {
460
1
      h.action(exception_to_status(e));
461
1
      return TILEDB_INVALID_CONTEXT;
462
1
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
1.95k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_ctx_cancel_tasks(tiledb_ctx_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*)
Line
Count
Source
431
39
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
39
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
39
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
39
      auto x{f(args...)};
454
39
      h.action_on_success();
455
39
      return x;
456
39
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
1
    } catch (const detail::InvalidContextException& e) {
460
1
      h.action(exception_to_status(e));
461
1
      return TILEDB_INVALID_CONTEXT;
462
1
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
39
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_ctx_set_tag(tiledb_ctx_handle_t*, char const*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, char const*)
Line
Count
Source
431
5.81k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
5.81k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
5.81k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
5.81k
      auto x{f(args...)};
454
5.81k
      h.action_on_success();
455
5.81k
      return x;
456
5.81k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
1
    } catch (const detail::InvalidContextException& e) {
460
1
      h.action(exception_to_status(e));
461
1
      return TILEDB_INVALID_CONTEXT;
462
1
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
2
    } catch (const StatusException& e) {
466
2
      h.action(e.extract_status());
467
2
      return TILEDB_ERR;
468
2
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
5.81k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_datatype_to_str(tiledb_datatype_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_datatype_t, char const**)
Line
Count
Source
431
96
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
96
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
96
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
96
      auto x{f(args...)};
454
96
      h.action_on_success();
455
96
      return x;
456
96
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
96
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_datatype_from_str(char const*, tiledb_datatype_t*)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, char const*, tiledb_datatype_t*)
Line
Count
Source
431
42
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
42
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
42
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
42
      auto x{f(args...)};
454
42
      h.action_on_success();
455
42
      return x;
456
42
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
42
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filesystem_to_str(tiledb_filesystem_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_filesystem_t, char const**)
Line
Count
Source
431
5
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
5
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
5
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
5
      auto x{f(args...)};
454
5
      h.action_on_success();
455
5
      return x;
456
5
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
5
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filesystem_from_str(char const*, tiledb_filesystem_t*)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, char const*, tiledb_filesystem_t*)
Line
Count
Source
431
5
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
5
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
5
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
5
      auto x{f(args...)};
454
5
      h.action_on_success();
455
5
      return x;
456
5
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
5
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_alloc(tiledb_ctx_handle_t*, tiledb_filter_type_t, tiledb_filter_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_filter_type_t, tiledb_filter_handle_t**)
Line
Count
Source
431
3.26k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
3.26k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
3.26k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
3.26k
      auto x{f(args...)};
454
3.26k
      h.action_on_success();
455
3.26k
      return x;
456
3.26k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
1
    } catch (const detail::InvalidContextException& e) {
460
1
      h.action(exception_to_status(e));
461
1
      return TILEDB_INVALID_CONTEXT;
462
1
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
2
    } catch (const StatusException& e) {
466
2
      h.action(e.extract_status());
467
2
      return TILEDB_ERR;
468
2
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
3.26k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_filter_free(tiledb_filter_handle_t**))>::function_from_void(tiledb_filter_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_filter_handle_t**)
Line
Count
Source
431
3.32k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
3.32k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
3.32k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
3.32k
      auto x{f(args...)};
454
3.32k
      h.action_on_success();
455
3.32k
      return x;
456
3.32k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
3.32k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_get_type(tiledb_filter_handle_t*, tiledb_filter_type_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_filter_handle_t*, tiledb_filter_type_t*)
Line
Count
Source
431
64
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
64
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
64
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
64
      auto x{f(args...)};
454
64
      h.action_on_success();
455
64
      return x;
456
64
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
1
    } catch (const detail::InvalidContextException& e) {
460
1
      h.action(exception_to_status(e));
461
1
      return TILEDB_INVALID_CONTEXT;
462
1
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
2
    } catch (const StatusException& e) {
466
2
      h.action(e.extract_status());
467
2
      return TILEDB_ERR;
468
2
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
64
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_set_option(tiledb_filter_handle_t*, tiledb_filter_option_t, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_filter_handle_t*, tiledb_filter_option_t, void const*)
Line
Count
Source
431
1.07k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
1.07k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
1.07k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
1.07k
      auto x{f(args...)};
454
1.07k
      h.action_on_success();
455
1.07k
      return x;
456
1.07k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
1
    } catch (const detail::InvalidContextException& e) {
460
1
      h.action(exception_to_status(e));
461
1
      return TILEDB_INVALID_CONTEXT;
462
1
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
6
    } catch (const StatusException& e) {
466
6
      h.action(e.extract_status());
467
6
      return TILEDB_ERR;
468
6
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
1.07k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_get_option(tiledb_filter_handle_t*, tiledb_filter_option_t, void*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_filter_handle_t*, tiledb_filter_option_t, void*)
Line
Count
Source
431
23
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
23
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
23
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
23
      auto x{f(args...)};
454
23
      h.action_on_success();
455
23
      return x;
456
23
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
1
    } catch (const detail::InvalidContextException& e) {
460
1
      h.action(exception_to_status(e));
461
1
      return TILEDB_INVALID_CONTEXT;
462
1
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
5
    } catch (const StatusException& e) {
466
5
      h.action(e.extract_status());
467
5
      return TILEDB_ERR;
468
5
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
23
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_type_to_str(tiledb_filter_type_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_filter_type_t, char const**)
Line
Count
Source
431
11
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
11
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
11
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
11
      auto x{f(args...)};
454
11
      h.action_on_success();
455
11
      return x;
456
11
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
11
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_type_from_str(char const*, tiledb_filter_type_t*)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, char const*, tiledb_filter_type_t*)
Line
Count
Source
431
17
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
17
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
17
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
17
      auto x{f(args...)};
454
17
      h.action_on_success();
455
17
      return x;
456
17
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
17
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_option_to_str(tiledb_filter_option_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_filter_option_t, char const**)
Line
Count
Source
431
3
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
3
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
3
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
3
      auto x{f(args...)};
454
3
      h.action_on_success();
455
3
      return x;
456
3
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
3
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_option_from_str(char const*, tiledb_filter_option_t*)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, char const*, tiledb_filter_option_t*)
Line
Count
Source
431
9
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
9
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
9
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
9
      auto x{f(args...)};
454
9
      h.action_on_success();
455
9
      return x;
456
9
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
9
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_list_alloc(tiledb_ctx_handle_t*, tiledb_filter_list_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, tiledb_filter_list_handle_t**)
Line
Count
Source
431
3.24k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
3.24k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
3.24k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
3.24k
      auto x{f(args...)};
454
3.24k
      h.action_on_success();
455
3.24k
      return x;
456
3.24k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
1
    } catch (const detail::InvalidContextException& e) {
460
1
      h.action(exception_to_status(e));
461
1
      return TILEDB_INVALID_CONTEXT;
462
1
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
3.24k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_filter_list_free(tiledb_filter_list_handle_t**))>::function_from_void(tiledb_filter_list_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_filter_list_handle_t**)
Line
Count
Source
431
3.27k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
3.27k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
3.27k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
3.27k
      auto x{f(args...)};
454
3.27k
      h.action_on_success();
455
3.27k
      return x;
456
3.27k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
3.27k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_list_add_filter(tiledb_filter_list_handle_t*, tiledb_filter_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_filter_list_handle_t*, tiledb_filter_handle_t*)
Line
Count
Source
431
3.25k
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
3.25k
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
3.25k
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
3.25k
      auto x{f(args...)};
454
3.25k
      h.action_on_success();
455
3.25k
      return x;
456
3.25k
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
1
    } catch (const detail::InvalidContextException& e) {
460
1
      h.action(exception_to_status(e));
461
1
      return TILEDB_INVALID_CONTEXT;
462
1
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
2
    } catch (const StatusException& e) {
466
2
      h.action(e.extract_status());
467
2
      return TILEDB_ERR;
468
2
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
3.25k
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_list_set_max_chunk_size(tiledb_filter_list_handle_t*, unsigned int)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_filter_list_handle_t*, unsigned int)
Line
Count
Source
431
5
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
5
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
5
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
5
      auto x{f(args...)};
454
5
      h.action_on_success();
455
5
      return x;
456
5
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
1
    } catch (const detail::InvalidContextException& e) {
460
1
      h.action(exception_to_status(e));
461
1
      return TILEDB_INVALID_CONTEXT;
462
1
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
5
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_list_get_nfilters(tiledb_filter_list_handle_t const*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_filter_list_handle_t const*, unsigned int*)
Line
Count
Source
431
83
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
83
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
83
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
83
      auto x{f(args...)};
454
83
      h.action_on_success();
455
83
      return x;
456
83
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
83
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_list_get_filter_from_index(tiledb_filter_list_handle_t const*, unsigned int, tiledb_filter_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_filter_list_handle_t const*, unsigned int, tiledb_filter_handle_t**)
Line
Count
Source
431
73
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
73
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
73
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
73
      auto x{f(args...)};
454
73
      h.action_on_success();
455
73
      return x;
456
73
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
2
    } catch (const detail::InvalidContextException& e) {
460
2
      h.action(exception_to_status(e));
461
2
      return TILEDB_INVALID_CONTEXT;
462
2
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
9
    } catch (const StatusException& e) {
466
9
      h.action(e.extract_status());
467
9
      return TILEDB_ERR;
468
9
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
73
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_list_get_max_chunk_size(tiledb_filter_list_handle_t const*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_filter_list_handle_t const*, unsigned int*)
Line
Count
Source
431
30
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
30
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
30
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
30
      auto x{f(args...)};
454
30
      h.action_on_success();
455
30
      return x;
456
30
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
1
    } catch (const detail::InvalidContextException& e) {
460
1
      h.action(exception_to_status(e));
461
1
      return TILEDB_INVALID_CONTEXT;
462
1
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
2
    } catch (const StatusException& e) {
466
2
      h.action(e.extract_status());
467
2
      return TILEDB_ERR;
468
2
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
30
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_create(tiledb_ctx_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*)
Line
Count
Source
431
41
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
41
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
41
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
41
      auto x{f(args...)};
454
41
      h.action_on_success();
455
41
      return x;
456
41
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
41
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_alloc(tiledb_ctx_handle_t*, char const*, tiledb_group_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, tiledb_group_handle_t**)
Line
Count
Source
431
47
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
47
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
47
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
47
      auto x{f(args...)};
454
47
      h.action_on_success();
455
47
      return x;
456
47
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
47
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_open(tiledb_group_handle_t*, tiledb_query_type_t)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_group_handle_t*, tiledb_query_type_t)
Line
Count
Source
431
127
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
127
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
127
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
127
      auto x{f(args...)};
454
127
      h.action_on_success();
455
127
      return x;
456
127
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
127
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_close(tiledb_group_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_group_handle_t*)
Line
Count
Source
431
123
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
123
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
123
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
123
      auto x{f(args...)};
454
123
      h.action_on_success();
455
123
      return x;
456
123
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
123
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_group_free(tiledb_group_handle_t**))>::function_from_void(tiledb_group_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_group_handle_t**)
Line
Count
Source
431
47
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
47
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
47
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
47
      auto x{f(args...)};
454
47
      h.action_on_success();
455
47
      return x;
456
47
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
47
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_set_config(tiledb_group_handle_t*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_group_handle_t*, tiledb_config_handle_t*)
Line
Count
Source
431
74
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
74
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
74
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
74
      auto x{f(args...)};
454
74
      h.action_on_success();
455
74
      return x;
456
74
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
74
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_config(tiledb_group_handle_t*, tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_group_handle_t*, tiledb_config_handle_t**)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_put_metadata(tiledb_group_handle_t*, char const*, tiledb_datatype_t, unsigned int, void const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_group_handle_t*, char const*, tiledb_datatype_t, unsigned int, void const*)
Line
Count
Source
431
32
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
32
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
32
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
32
      auto x{f(args...)};
454
32
      h.action_on_success();
455
32
      return x;
456
32
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
7
    } catch (const StatusException& e) {
466
7
      h.action(e.extract_status());
467
7
      return TILEDB_ERR;
468
7
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
32
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_delete_group(tiledb_group_handle_t*, char const*, unsigned char)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_group_handle_t*, char const*, unsigned char)
Line
Count
Source
431
6
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
6
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
6
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
6
      auto x{f(args...)};
454
6
      h.action_on_success();
455
6
      return x;
456
6
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
2
    } catch (const StatusException& e) {
466
2
      h.action(e.extract_status());
467
2
      return TILEDB_ERR;
468
2
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
6
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_delete_metadata(tiledb_group_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_group_handle_t*, char const*)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_metadata(tiledb_group_handle_t*, char const*, tiledb_datatype_t*, unsigned int*, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_group_handle_t*, char const*, tiledb_datatype_t*, unsigned int*, void const**)
Line
Count
Source
431
7
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
7
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
7
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
7
      auto x{f(args...)};
454
7
      h.action_on_success();
455
7
      return x;
456
7
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
7
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_metadata_num(tiledb_group_handle_t*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_group_handle_t*, unsigned long long*)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_metadata_from_index(tiledb_group_handle_t*, unsigned long long, char const**, unsigned int*, tiledb_datatype_t*, unsigned int*, void const**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_group_handle_t*, unsigned long long, char const**, unsigned int*, tiledb_datatype_t*, unsigned int*, void const**)
Line
Count
Source
431
5
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
5
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
5
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
5
      auto x{f(args...)};
454
5
      h.action_on_success();
455
5
      return x;
456
5
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
2
    } catch (const StatusException& e) {
466
2
      h.action(e.extract_status());
467
2
      return TILEDB_ERR;
468
2
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
5
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_has_metadata_key(tiledb_group_handle_t*, char const*, tiledb_datatype_t*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_group_handle_t*, char const*, tiledb_datatype_t*, int*)
Line
Count
Source
431
4
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4
      auto x{f(args...)};
454
4
      h.action_on_success();
455
4
      return x;
456
4
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_add_member(tiledb_group_handle_t*, char const*, unsigned char, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_group_handle_t*, char const*, unsigned char, char const*)
Line
Count
Source
431
42
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
42
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
42
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
42
      auto x{f(args...)};
454
42
      h.action_on_success();
455
42
      return x;
456
42
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
42
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_remove_member(tiledb_group_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_group_handle_t*, char const*)
Line
Count
Source
431
18
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
18
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
18
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
18
      auto x{f(args...)};
454
18
      h.action_on_success();
455
18
      return x;
456
18
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
18
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_member_count(tiledb_group_handle_t*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_group_handle_t*, unsigned long long*)
Line
Count
Source
431
45
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
45
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
45
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
45
      auto x{f(args...)};
454
45
      h.action_on_success();
455
45
      return x;
456
45
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
45
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_member_by_index(tiledb_group_handle_t*, unsigned long long, char**, tiledb_object_t*, char**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_group_handle_t*, unsigned long long, char**, tiledb_object_t*, char**)
Line
Count
Source
431
69
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
69
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
69
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
69
      auto x{f(args...)};
454
69
      h.action_on_success();
455
69
      return x;
456
69
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
3
    } catch (...) {
472
3
      h.action(CAPIStatusError(
473
3
          "TileDB Internal: unknown exception type; no further information"));
474
3
      return TILEDB_ERR;
475
3
    }
476
69
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_member_by_name(tiledb_group_handle_t*, char const*, char**, tiledb_object_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_group_handle_t*, char const*, char**, tiledb_object_t*)
Line
Count
Source
431
2
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
2
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
2
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
2
      auto x{f(args...)};
454
2
      h.action_on_success();
455
2
      return x;
456
2
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
1
    } catch (...) {
472
1
      h.action(CAPIStatusError(
473
1
          "TileDB Internal: unknown exception type; no further information"));
474
1
      return TILEDB_ERR;
475
1
    }
476
2
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_is_relative_uri_by_name(tiledb_group_handle_t*, char const*, unsigned char*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_group_handle_t*, char const*, unsigned char*)
Line
Count
Source
431
13
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
13
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
13
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
13
      auto x{f(args...)};
454
13
      h.action_on_success();
455
13
      return x;
456
13
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
1
    } catch (...) {
472
1
      h.action(CAPIStatusError(
473
1
          "TileDB Internal: unknown exception type; no further information"));
474
1
      return TILEDB_ERR;
475
1
    }
476
13
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_is_open(tiledb_group_handle_t*, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_group_handle_t*, int*)
Line
Count
Source
431
16
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
16
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
16
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
16
      auto x{f(args...)};
454
16
      h.action_on_success();
455
16
      return x;
456
16
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
16
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_uri(tiledb_group_handle_t*, char const**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_group_handle_t*, char const**)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_query_type(tiledb_group_handle_t*, tiledb_query_type_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_group_handle_t*, tiledb_query_type_t*)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_dump_str(tiledb_group_handle_t*, char**, unsigned char)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_group_handle_t*, char**, unsigned char)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_group(tiledb_group_handle_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_group_handle_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)
Line
Count
Source
431
4
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4
      auto x{f(args...)};
454
4
      h.action_on_success();
455
4
      return x;
456
4
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_group(tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_group_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_group_handle_t*)
Line
Count
Source
431
4
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4
      auto x{f(args...)};
454
4
      h.action_on_success();
455
4
      return x;
456
4
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4
  };
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_group_metadata(tiledb_group_handle_t const*, tiledb_serialization_type_t, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_group_handle_t const*, tiledb_serialization_type_t, tiledb_buffer_handle_t**)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_group_metadata(tiledb_group_handle_t*, tiledb_serialization_type_t, tiledb_buffer_handle_t const*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_group_handle_t*, tiledb_serialization_type_t, tiledb_buffer_handle_t const*)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_consolidate_metadata(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)
Line
Count
Source
431
6
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
6
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
6
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
6
      auto x{f(args...)};
454
6
      h.action_on_success();
455
6
      return x;
456
6
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
6
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_vacuum_metadata(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)
Line
Count
Source
431
3
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
3
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
3
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
3
      auto x{f(args...)};
454
3
      h.action_on_success();
455
3
      return x;
456
3
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
3
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_object_type_to_str(tiledb_object_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_object_t, char const**)
Line
Count
Source
431
3
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
3
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
3
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
3
      auto x{f(args...)};
454
3
      h.action_on_success();
455
3
      return x;
456
3
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
3
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_object_type_from_str(char const*, tiledb_object_t*)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, char const*, tiledb_object_t*)
Line
Count
Source
431
3
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
3
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
3
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
3
      auto x{f(args...)};
454
3
      h.action_on_success();
455
3
      return x;
456
3
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
3
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_walk_order_to_str(tiledb_walk_order_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_walk_order_t, char const**)
Line
Count
Source
431
4
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4
      auto x{f(args...)};
454
4
      h.action_on_success();
455
4
      return x;
456
4
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_walk_order_from_str(char const*, tiledb_walk_order_t*)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, char const*, tiledb_walk_order_t*)
Line
Count
Source
431
4
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
4
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
4
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
4
      auto x{f(args...)};
454
4
      h.action_on_success();
455
4
      return x;
456
4
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
4
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_type_to_str(tiledb_query_type_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, tiledb_query_type_t, char const**)
Line
Count
Source
431
5
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
5
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
5
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
5
      auto x{f(args...)};
454
5
      h.action_on_success();
455
5
      return x;
456
5
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
5
  };
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_type_from_str(char const*, tiledb_query_type_t*)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, char const*, tiledb_query_type_t*)
Line
Count
Source
431
5
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
5
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
5
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
5
      auto x{f(args...)};
454
5
      h.action_on_success();
455
5
      return x;
456
5
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
5
  };
tiledb::api::CAPIFunction<&(tf_always_good()), tiledb::api::detail::ExceptionActionDetailCtxErr>::function(tiledb::api::detail::ExceptionActionDetailCtxErr&)
Line
Count
Source
431
3
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
3
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
3
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
3
      auto x{f(args...)};
454
3
      h.action_on_success();
455
3
      return x;
456
3
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
1
    } catch (const detail::InvalidContextException& e) {
460
1
      h.action(exception_to_status(e));
461
1
      return TILEDB_INVALID_CONTEXT;
462
1
    } catch (const detail::InvalidErrorException& e) {
463
1
      h.action(exception_to_status(e));
464
1
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
3
  };
tiledb::api::CAPIFunction<&(tf_always_throw()), tiledb::api::detail::ExceptionActionDetailCtxErr>::function(tiledb::api::detail::ExceptionActionDetailCtxErr&)
Line
Count
Source
431
1
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
1
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
1
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
1
      auto x{f(args...)};
454
1
      h.action_on_success();
455
1
      return x;
456
1
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
1
  };
tiledb::api::CAPIFunction<&(tf_assign(int, int*)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, int, int*)
Line
Count
Source
431
1
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
1
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
1
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
1
      auto x{f(args...)};
454
1
      h.action_on_success();
455
1
      return x;
456
1
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
1
  };
tiledb::api::CAPIFunction<&(tf_always_throw()), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&)
Line
Count
Source
431
1
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
1
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
1
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
1
      auto x{f(args...)};
454
1
      h.action_on_success();
455
1
      return x;
456
1
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
1
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tf_void_assign(int, int*))>::function_from_void(int, int*)), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&, int, int*)
Line
Count
Source
431
1
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
1
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
1
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
1
      auto x{f(args...)};
454
1
      h.action_on_success();
455
1
      return x;
456
1
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
1
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tf_void_throw())>::function_from_void()), tiledb::api::detail::ExceptionActionDetail>::function(tiledb::api::detail::ExceptionActionDetail&)
Line
Count
Source
431
1
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
1
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
1
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
1
      auto x{f(args...)};
454
1
      h.action_on_success();
455
1
      return x;
456
1
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
1
  };
tiledb::api::CAPIFunction<&(tf_context_assign(tiledb_ctx_handle_t*, int, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*, int, int*)
Line
Count
Source
431
1
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
1
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
1
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
1
      auto x{f(args...)};
454
1
      h.action_on_success();
455
1
      return x;
456
1
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
1
  };
tiledb::api::CAPIFunction<&(tf_context_throw(tiledb_ctx_handle_t*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, tiledb_ctx_handle_t*)
Line
Count
Source
431
1
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
1
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
1
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
1
      auto x{f(args...)};
454
1
      h.action_on_success();
455
1
      return x;
456
1
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
1
  };
tiledb::api::CAPIFunction<&(tf_assign(int, int*)), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&, int, int*)
Line
Count
Source
431
1
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
1
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
1
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
1
      auto x{f(args...)};
454
1
      h.action_on_success();
455
1
      return x;
456
1
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
1
  };
tiledb::api::CAPIFunction<&(tf_always_throw()), tiledb::api::detail::ExceptionActionDetailCtx>::function(tiledb::api::detail::ExceptionActionDetailCtx&)
Line
Count
Source
431
1
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
1
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
1
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
1
      auto x{f(args...)};
454
1
      h.action_on_success();
455
1
      return x;
456
1
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
1
  };
tiledb::api::CAPIFunction<&(tf_assign(int, int*)), tiledb::api::detail::ExceptionActionDetailErr>::function(tiledb::api::detail::ExceptionActionDetailErr&, int, int*)
Line
Count
Source
431
1
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
1
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
1
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
1
      auto x{f(args...)};
454
1
      h.action_on_success();
455
1
      return x;
456
1
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
0
    } catch (const StatusException& e) {
466
0
      h.action(e.extract_status());
467
0
      return TILEDB_ERR;
468
0
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
1
  };
tiledb::api::CAPIFunction<&(tf_always_throw()), tiledb::api::detail::ExceptionActionDetailErr>::function(tiledb::api::detail::ExceptionActionDetailErr&)
Line
Count
Source
431
1
  static capi_return_t function(H& h, Args... args) {
432
    /*
433
     * The order of the catch blocks is not arbitrary:
434
     * - `std::bad_alloc` comes first because it overrides other problems
435
     * - `InvalidContextException` and `InvalidErrorException` come next,
436
     *    because they have return codes that override the generic `TILEDB_ERR`
437
     * - `StatusException` is derived from `std::exception`, so it must precede
438
     *   it in order to be caught separately
439
     * - `std::exception` is for all other expected exceptions
440
     * - `...` is only for ultimate exception safety. This catch block should
441
     *   never execute.
442
     */
443
1
    try {
444
      /*
445
       * If error-handling arguments are invalid, `validate` will throw and the
446
       * underlying function will not execute.
447
       */
448
1
      h.validate();
449
      /*
450
       * Note that we don't need std::forward here because all the arguments
451
       * must have "C" linkage.
452
       */
453
1
      auto x{f(args...)};
454
1
      h.action_on_success();
455
1
      return x;
456
1
    } catch (const std::bad_alloc& e) {
457
0
      h.action(exception_to_status(e));
458
0
      return TILEDB_OOM;
459
0
    } catch (const detail::InvalidContextException& e) {
460
0
      h.action(exception_to_status(e));
461
0
      return TILEDB_INVALID_CONTEXT;
462
0
    } catch (const detail::InvalidErrorException& e) {
463
0
      h.action(exception_to_status(e));
464
0
      return TILEDB_INVALID_ERROR;
465
1
    } catch (const StatusException& e) {
466
1
      h.action(e.extract_status());
467
1
      return TILEDB_ERR;
468
1
    } catch (const std::exception& e) {
469
0
      h.action(exception_to_status(e));
470
0
      return TILEDB_ERR;
471
0
    } catch (...) {
472
0
      h.action(CAPIStatusError(
473
0
          "TileDB Internal: unknown exception type; no further information"));
474
0
      return TILEDB_ERR;
475
0
    }
476
1
  };
477
478
  /**
479
   * The plain wrapper function.
480
   *
481
   * @param args Arguments to an API implementation function
482
   * @return The return value of the call to the implementation function.
483
   */
484
10.2k
  inline static capi_return_t function_plain(Args... args) {
485
10.2k
    ExceptionAction action{};
486
10.2k
    return function(action, args...);
487
10.2k
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_type_to_str(tiledb_array_type_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function_plain(tiledb_array_type_t, char const**)
Line
Count
Source
484
2
  inline static capi_return_t function_plain(Args... args) {
485
2
    ExceptionAction action{};
486
2
    return function(action, args...);
487
2
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_array_type_from_str(char const*, tiledb_array_type_t*)), tiledb::api::detail::ExceptionActionDetail>::function_plain(char const*, tiledb_array_type_t*)
Line
Count
Source
484
2
  inline static capi_return_t function_plain(Args... args) {
485
2
    ExceptionAction action{};
486
2
    return function(action, args...);
487
2
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_layout_to_str(tiledb_layout_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function_plain(tiledb_layout_t, char const**)
Line
Count
Source
484
4
  inline static capi_return_t function_plain(Args... args) {
485
4
    ExceptionAction action{};
486
4
    return function(action, args...);
487
4
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_layout_from_str(char const*, tiledb_layout_t*)), tiledb::api::detail::ExceptionActionDetail>::function_plain(char const*, tiledb_layout_t*)
Line
Count
Source
484
4
  inline static capi_return_t function_plain(Args... args) {
485
4
    ExceptionAction action{};
486
4
    return function(action, args...);
487
4
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_encryption_type_to_str(tiledb_encryption_type_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function_plain(tiledb_encryption_type_t, char const**)
Line
Count
Source
484
2
  inline static capi_return_t function_plain(Args... args) {
485
2
    ExceptionAction action{};
486
2
    return function(action, args...);
487
2
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_encryption_type_from_str(char const*, tiledb_encryption_type_t*)), tiledb::api::detail::ExceptionActionDetail>::function_plain(char const*, tiledb_encryption_type_t*)
Line
Count
Source
484
2
  inline static capi_return_t function_plain(Args... args) {
485
2
    ExceptionAction action{};
486
2
    return function(action, args...);
487
2
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_status_to_str(tiledb_query_status_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function_plain(tiledb_query_status_t, char const**)
Line
Count
Source
484
5
  inline static capi_return_t function_plain(Args... args) {
485
5
    ExceptionAction action{};
486
5
    return function(action, args...);
487
5
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_status_from_str(char const*, tiledb_query_status_t*)), tiledb::api::detail::ExceptionActionDetail>::function_plain(char const*, tiledb_query_status_t*)
Line
Count
Source
484
5
  inline static capi_return_t function_plain(Args... args) {
485
5
    ExceptionAction action{};
486
5
    return function(action, args...);
487
5
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialization_type_to_str(tiledb_serialization_type_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function_plain(tiledb_serialization_type_t, char const**)
Line
Count
Source
484
2
  inline static capi_return_t function_plain(Args... args) {
485
2
    ExceptionAction action{};
486
2
    return function(action, args...);
487
2
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialization_type_from_str(char const*, tiledb_serialization_type_t*)), tiledb::api::detail::ExceptionActionDetail>::function_plain(char const*, tiledb_serialization_type_t*)
Line
Count
Source
484
2
  inline static capi_return_t function_plain(Args... args) {
485
2
    ExceptionAction action{};
486
2
    return function(action, args...);
487
2
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_mode_to_str(tiledb_vfs_mode_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function_plain(tiledb_vfs_mode_t, char const**)
Line
Count
Source
484
3
  inline static capi_return_t function_plain(Args... args) {
485
3
    ExceptionAction action{};
486
3
    return function(action, args...);
487
3
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_vfs_mode_from_str(char const*, tiledb_vfs_mode_t*)), tiledb::api::detail::ExceptionActionDetail>::function_plain(char const*, tiledb_vfs_mode_t*)
Line
Count
Source
484
3
  inline static capi_return_t function_plain(Args... args) {
485
3
    ExceptionAction action{};
486
3
    return function(action, args...);
487
3
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_enable()), tiledb::api::detail::ExceptionActionDetail>::function_plain()
Line
Count
Source
484
4
  inline static capi_return_t function_plain(Args... args) {
485
4
    ExceptionAction action{};
486
4
    return function(action, args...);
487
4
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_disable()), tiledb::api::detail::ExceptionActionDetail>::function_plain()
Line
Count
Source
484
2
  inline static capi_return_t function_plain(Args... args) {
485
2
    ExceptionAction action{};
486
2
    return function(action, args...);
487
2
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_reset()), tiledb::api::detail::ExceptionActionDetail>::function_plain()
Line
Count
Source
484
4
  inline static capi_return_t function_plain(Args... args) {
485
4
    ExceptionAction action{};
486
4
    return function(action, args...);
487
4
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_dump(__sFILE*)), tiledb::api::detail::ExceptionActionDetail>::function_plain(__sFILE*)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_dump_str(char**)), tiledb::api::detail::ExceptionActionDetail>::function_plain(char**)
Line
Count
Source
484
2
  inline static capi_return_t function_plain(Args... args) {
485
2
    ExceptionAction action{};
486
2
    return function(action, args...);
487
2
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_raw_dump(__sFILE*)), tiledb::api::detail::ExceptionActionDetail>::function_plain(__sFILE*)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_raw_dump_str(char**)), tiledb::api::detail::ExceptionActionDetail>::function_plain(char**)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_stats_free_str(char**)), tiledb::api::detail::ExceptionActionDetail>::function_plain(char**)
Line
Count
Source
484
2
  inline static capi_return_t function_plain(Args... args) {
485
2
    ExceptionAction action{};
486
2
    return function(action, args...);
487
2
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_heap_profiler_enable(char const*, unsigned long long, unsigned long long, unsigned long long)), tiledb::api::detail::ExceptionActionDetail>::function_plain(char const*, unsigned long long, unsigned long long, unsigned long long)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_consolidation_plan_free_json_str(char**)), tiledb::api::detail::ExceptionActionDetail>::function_plain(char**)
Line
Count
Source
484
2
  inline static capi_return_t function_plain(Args... args) {
485
2
    ExceptionAction action{};
486
2
    return function(action, args...);
487
2
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::common::detail::tiledb_mime_type_to_str(tiledb_mime_type_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function_plain(tiledb_mime_type_t, char const**)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::common::detail::tiledb_mime_type_from_str(char const*, tiledb_mime_type_t*)), tiledb::api::detail::ExceptionActionDetail>::function_plain(char const*, tiledb_mime_type_t*)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_error_message(tiledb_error_handle_t*, char const**)), tiledb::api::detail::ExceptionActionDetail>::function_plain(tiledb_error_handle_t*, char const**)
Line
Count
Source
484
270
  inline static capi_return_t function_plain(Args... args) {
485
270
    ExceptionAction action{};
486
270
    return function(action, args...);
487
270
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_compare(tiledb_config_handle_t*, tiledb_config_handle_t*, unsigned char*)), tiledb::api::detail::ExceptionActionDetail>::function_plain(tiledb_config_handle_t*, tiledb_config_handle_t*, unsigned char*)
Line
Count
Source
484
12
  inline static capi_return_t function_plain(Args... args) {
485
12
    ExceptionAction action{};
486
12
    return function(action, args...);
487
12
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_ctx_alloc(tiledb_config_handle_t*, tiledb_ctx_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::function_plain(tiledb_config_handle_t*, tiledb_ctx_handle_t**)
Line
Count
Source
484
9.68k
  inline static capi_return_t function_plain(Args... args) {
485
9.68k
    ExceptionAction action{};
486
9.68k
    return function(action, args...);
487
9.68k
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_datatype_to_str(tiledb_datatype_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function_plain(tiledb_datatype_t, char const**)
Line
Count
Source
484
96
  inline static capi_return_t function_plain(Args... args) {
485
96
    ExceptionAction action{};
486
96
    return function(action, args...);
487
96
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_datatype_from_str(char const*, tiledb_datatype_t*)), tiledb::api::detail::ExceptionActionDetail>::function_plain(char const*, tiledb_datatype_t*)
Line
Count
Source
484
42
  inline static capi_return_t function_plain(Args... args) {
485
42
    ExceptionAction action{};
486
42
    return function(action, args...);
487
42
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filesystem_to_str(tiledb_filesystem_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function_plain(tiledb_filesystem_t, char const**)
Line
Count
Source
484
5
  inline static capi_return_t function_plain(Args... args) {
485
5
    ExceptionAction action{};
486
5
    return function(action, args...);
487
5
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filesystem_from_str(char const*, tiledb_filesystem_t*)), tiledb::api::detail::ExceptionActionDetail>::function_plain(char const*, tiledb_filesystem_t*)
Line
Count
Source
484
5
  inline static capi_return_t function_plain(Args... args) {
485
5
    ExceptionAction action{};
486
5
    return function(action, args...);
487
5
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_type_to_str(tiledb_filter_type_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function_plain(tiledb_filter_type_t, char const**)
Line
Count
Source
484
11
  inline static capi_return_t function_plain(Args... args) {
485
11
    ExceptionAction action{};
486
11
    return function(action, args...);
487
11
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_type_from_str(char const*, tiledb_filter_type_t*)), tiledb::api::detail::ExceptionActionDetail>::function_plain(char const*, tiledb_filter_type_t*)
Line
Count
Source
484
17
  inline static capi_return_t function_plain(Args... args) {
485
17
    ExceptionAction action{};
486
17
    return function(action, args...);
487
17
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_option_to_str(tiledb_filter_option_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function_plain(tiledb_filter_option_t, char const**)
Line
Count
Source
484
3
  inline static capi_return_t function_plain(Args... args) {
485
3
    ExceptionAction action{};
486
3
    return function(action, args...);
487
3
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_option_from_str(char const*, tiledb_filter_option_t*)), tiledb::api::detail::ExceptionActionDetail>::function_plain(char const*, tiledb_filter_option_t*)
Line
Count
Source
484
9
  inline static capi_return_t function_plain(Args... args) {
485
9
    ExceptionAction action{};
486
9
    return function(action, args...);
487
9
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_object_type_to_str(tiledb_object_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function_plain(tiledb_object_t, char const**)
Line
Count
Source
484
3
  inline static capi_return_t function_plain(Args... args) {
485
3
    ExceptionAction action{};
486
3
    return function(action, args...);
487
3
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_object_type_from_str(char const*, tiledb_object_t*)), tiledb::api::detail::ExceptionActionDetail>::function_plain(char const*, tiledb_object_t*)
Line
Count
Source
484
3
  inline static capi_return_t function_plain(Args... args) {
485
3
    ExceptionAction action{};
486
3
    return function(action, args...);
487
3
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_walk_order_to_str(tiledb_walk_order_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function_plain(tiledb_walk_order_t, char const**)
Line
Count
Source
484
4
  inline static capi_return_t function_plain(Args... args) {
485
4
    ExceptionAction action{};
486
4
    return function(action, args...);
487
4
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_walk_order_from_str(char const*, tiledb_walk_order_t*)), tiledb::api::detail::ExceptionActionDetail>::function_plain(char const*, tiledb_walk_order_t*)
Line
Count
Source
484
4
  inline static capi_return_t function_plain(Args... args) {
485
4
    ExceptionAction action{};
486
4
    return function(action, args...);
487
4
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_type_to_str(tiledb_query_type_t, char const**)), tiledb::api::detail::ExceptionActionDetail>::function_plain(tiledb_query_type_t, char const**)
Line
Count
Source
484
5
  inline static capi_return_t function_plain(Args... args) {
485
5
    ExceptionAction action{};
486
5
    return function(action, args...);
487
5
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_query_type_from_str(char const*, tiledb_query_type_t*)), tiledb::api::detail::ExceptionActionDetail>::function_plain(char const*, tiledb_query_type_t*)
Line
Count
Source
484
5
  inline static capi_return_t function_plain(Args... args) {
485
5
    ExceptionAction action{};
486
5
    return function(action, args...);
487
5
  }
tiledb::api::CAPIFunction<&(tf_assign(int, int*)), tiledb::api::detail::ExceptionActionDetail>::function_plain(int, int*)
Line
Count
Source
484
1
  inline static capi_return_t function_plain(Args... args) {
485
1
    ExceptionAction action{};
486
1
    return function(action, args...);
487
1
  }
tiledb::api::CAPIFunction<&(tf_always_throw()), tiledb::api::detail::ExceptionActionDetail>::function_plain()
Line
Count
Source
484
1
  inline static capi_return_t function_plain(Args... args) {
485
1
    ExceptionAction action{};
486
1
    return function(action, args...);
487
1
  }
488
489
  /**
490
   * The wrapper function returning void. It's the same as the full wrapper
491
   * function but suppresses the return value.
492
   *
493
   * @param args Arguments to an API implementation function
494
   */
495
252k
  inline static void void_function(Args... args) {
496
252k
    ExceptionAction action{};
497
252k
    (void)function(action, args...);
498
252k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_buffer_list_free(tiledb_buffer_list_t**))>::function_from_void(tiledb_buffer_list_t**)), tiledb::api::detail::ExceptionActionDetail>::void_function(tiledb_buffer_list_t**)
Line
Count
Source
495
2.42k
  inline static void void_function(Args... args) {
496
2.42k
    ExceptionAction action{};
497
2.42k
    (void)function(action, args...);
498
2.42k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_attribute_free(tiledb_attribute_t**))>::function_from_void(tiledb_attribute_t**)), tiledb::api::detail::ExceptionActionDetail>::void_function(tiledb_attribute_t**)
Line
Count
Source
495
20.6k
  inline static void void_function(Args... args) {
496
20.6k
    ExceptionAction action{};
497
20.6k
    (void)function(action, args...);
498
20.6k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_domain_free(tiledb_domain_t**))>::function_from_void(tiledb_domain_t**)), tiledb::api::detail::ExceptionActionDetail>::void_function(tiledb_domain_t**)
Line
Count
Source
495
29.1k
  inline static void void_function(Args... args) {
496
29.1k
    ExceptionAction action{};
497
29.1k
    (void)function(action, args...);
498
29.1k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_dimension_free(tiledb_dimension_t**))>::function_from_void(tiledb_dimension_t**)), tiledb::api::detail::ExceptionActionDetail>::void_function(tiledb_dimension_t**)
Line
Count
Source
495
27.2k
  inline static void void_function(Args... args) {
496
27.2k
    ExceptionAction action{};
497
27.2k
    (void)function(action, args...);
498
27.2k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_array_schema_free(tiledb_array_schema_t**))>::function_from_void(tiledb_array_schema_t**)), tiledb::api::detail::ExceptionActionDetail>::void_function(tiledb_array_schema_t**)
Line
Count
Source
495
58.1k
  inline static void void_function(Args... args) {
496
58.1k
    ExceptionAction action{};
497
58.1k
    (void)function(action, args...);
498
58.1k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_array_schema_evolution_free(tiledb_array_schema_evolution_t**))>::function_from_void(tiledb_array_schema_evolution_t**)), tiledb::api::detail::ExceptionActionDetail>::void_function(tiledb_array_schema_evolution_t**)
Line
Count
Source
495
13
  inline static void void_function(Args... args) {
496
13
    ExceptionAction action{};
497
13
    (void)function(action, args...);
498
13
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_query_free(tiledb_query_t**))>::function_from_void(tiledb_query_t**)), tiledb::api::detail::ExceptionActionDetail>::void_function(tiledb_query_t**)
Line
Count
Source
495
27.9k
  inline static void void_function(Args... args) {
496
27.9k
    ExceptionAction action{};
497
27.9k
    (void)function(action, args...);
498
27.9k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_subarray_free(tiledb_subarray_t**))>::function_from_void(tiledb_subarray_t**)), tiledb::api::detail::ExceptionActionDetail>::void_function(tiledb_subarray_t**)
Line
Count
Source
495
4.22k
  inline static void void_function(Args... args) {
496
4.22k
    ExceptionAction action{};
497
4.22k
    (void)function(action, args...);
498
4.22k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_query_condition_free(tiledb_query_condition_t**))>::function_from_void(tiledb_query_condition_t**)), tiledb::api::detail::ExceptionActionDetail>::void_function(tiledb_query_condition_t**)
Line
Count
Source
495
9.35k
  inline static void void_function(Args... args) {
496
9.35k
    ExceptionAction action{};
497
9.35k
    (void)function(action, args...);
498
9.35k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_array_free(tiledb_array_t**))>::function_from_void(tiledb_array_t**)), tiledb::api::detail::ExceptionActionDetail>::void_function(tiledb_array_t**)
Line
Count
Source
495
28.7k
  inline static void void_function(Args... args) {
496
28.7k
    ExceptionAction action{};
497
28.7k
    (void)function(action, args...);
498
28.7k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_vfs_free(tiledb_vfs_t**))>::function_from_void(tiledb_vfs_t**)), tiledb::api::detail::ExceptionActionDetail>::void_function(tiledb_vfs_t**)
Line
Count
Source
495
5.32k
  inline static void void_function(Args... args) {
496
5.32k
    ExceptionAction action{};
497
5.32k
    (void)function(action, args...);
498
5.32k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_vfs_fh_free(tiledb_vfs_fh_t**))>::function_from_void(tiledb_vfs_fh_t**)), tiledb::api::detail::ExceptionActionDetail>::void_function(tiledb_vfs_fh_t**)
Line
Count
Source
495
86
  inline static void void_function(Args... args) {
496
86
    ExceptionAction action{};
497
86
    (void)function(action, args...);
498
86
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_fragment_info_free(tiledb_fragment_info_t**))>::function_from_void(tiledb_fragment_info_t**)), tiledb::api::detail::ExceptionActionDetail>::void_function(tiledb_fragment_info_t**)
Line
Count
Source
495
113
  inline static void void_function(Args... args) {
496
113
    ExceptionAction action{};
497
113
    (void)function(action, args...);
498
113
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_consolidation_plan_free(tiledb_consolidation_plan_t**))>::function_from_void(tiledb_consolidation_plan_t**)), tiledb::api::detail::ExceptionActionDetail>::void_function(tiledb_consolidation_plan_t**)
Line
Count
Source
495
12
  inline static void void_function(Args... args) {
496
12
    ExceptionAction action{};
497
12
    (void)function(action, args...);
498
12
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_buffer_free(tiledb_buffer_handle_t**))>::function_from_void(tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::void_function(tiledb_buffer_handle_t**)
Line
Count
Source
495
5.00k
  inline static void void_function(Args... args) {
496
5.00k
    ExceptionAction action{};
497
5.00k
    (void)function(action, args...);
498
5.00k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_error_free(tiledb_error_handle_t**))>::function_from_void(tiledb_error_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::void_function(tiledb_error_handle_t**)
Line
Count
Source
495
290
  inline static void void_function(Args... args) {
496
290
    ExceptionAction action{};
497
290
    (void)function(action, args...);
498
290
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_config_free(tiledb_config_handle_t**))>::function_from_void(tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::void_function(tiledb_config_handle_t**)
Line
Count
Source
495
17.6k
  inline static void void_function(Args... args) {
496
17.6k
    ExceptionAction action{};
497
17.6k
    (void)function(action, args...);
498
17.6k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_config_iter_free(tiledb_config_iter_handle_t**))>::function_from_void(tiledb_config_iter_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::void_function(tiledb_config_iter_handle_t**)
Line
Count
Source
495
27
  inline static void void_function(Args... args) {
496
27
    ExceptionAction action{};
497
27
    (void)function(action, args...);
498
27
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_ctx_free(tiledb_ctx_handle_t**))>::function_from_void(tiledb_ctx_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::void_function(tiledb_ctx_handle_t**)
Line
Count
Source
495
9.67k
  inline static void void_function(Args... args) {
496
9.67k
    ExceptionAction action{};
497
9.67k
    (void)function(action, args...);
498
9.67k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_filter_free(tiledb_filter_handle_t**))>::function_from_void(tiledb_filter_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::void_function(tiledb_filter_handle_t**)
Line
Count
Source
495
3.32k
  inline static void void_function(Args... args) {
496
3.32k
    ExceptionAction action{};
497
3.32k
    (void)function(action, args...);
498
3.32k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_filter_list_free(tiledb_filter_list_handle_t**))>::function_from_void(tiledb_filter_list_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::void_function(tiledb_filter_list_handle_t**)
Line
Count
Source
495
3.27k
  inline static void void_function(Args... args) {
496
3.27k
    ExceptionAction action{};
497
3.27k
    (void)function(action, args...);
498
3.27k
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_group_free(tiledb_group_handle_t**))>::function_from_void(tiledb_group_handle_t**)), tiledb::api::detail::ExceptionActionDetail>::void_function(tiledb_group_handle_t**)
Line
Count
Source
495
47
  inline static void void_function(Args... args) {
496
47
    ExceptionAction action{};
497
47
    (void)function(action, args...);
498
47
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tf_void_assign(int, int*))>::function_from_void(int, int*)), tiledb::api::detail::ExceptionActionDetail>::void_function(int, int*)
Line
Count
Source
495
1
  inline static void void_function(Args... args) {
496
1
    ExceptionAction action{};
497
1
    (void)function(action, args...);
498
1
  };
tiledb::api::CAPIFunction<&(tiledb::api::CAPIFunctionVoid<&(tf_void_throw())>::function_from_void()), tiledb::api::detail::ExceptionActionDetail>::void_function()
Line
Count
Source
495
1
  inline static void void_function(Args... args) {
496
1
    ExceptionAction action{};
497
1
    (void)function(action, args...);
498
1
  };
499
500
  /**
501
   * Wrapper function for interface functions with an error argument but whose
502
   * corresponding implementation functions do not need one.
503
   *
504
   * @param ctx Object to receive any error message
505
   * @param args Arguments forwarded from API function
506
   * @return The return value of the call to the implementation function.
507
   */
508
  inline static capi_return_t function_context(
509
12.4k
      tiledb_ctx_handle_t* ctx, Args... args) {
510
12.4k
    tiledb::api::ExceptionActionCtx action{ctx};
511
12.4k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
12.4k
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_config(tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_config_handle_t**)
Line
Count
Source
509
2
      tiledb_ctx_handle_t* ctx, Args... args) {
510
2
    tiledb::api::ExceptionActionCtx action{ctx};
511
2
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
2
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_alloc(tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_buffer_handle_t**)
Line
Count
Source
509
2.42k
      tiledb_ctx_handle_t* ctx, Args... args) {
510
2.42k
    tiledb::api::ExceptionActionCtx action{ctx};
511
2.42k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
2.42k
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_set_type(tiledb_buffer_handle_t*, tiledb_datatype_t)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_buffer_handle_t*, tiledb_datatype_t)
Line
Count
Source
509
1
      tiledb_ctx_handle_t* ctx, Args... args) {
510
1
    tiledb::api::ExceptionActionCtx action{ctx};
511
1
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
1
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_get_type(tiledb_buffer_handle_t const*, tiledb_datatype_t*)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_datatype_t*)
Line
Count
Source
509
2
      tiledb_ctx_handle_t* ctx, Args... args) {
510
2
    tiledb::api::ExceptionActionCtx action{ctx};
511
2
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
2
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_get_data(tiledb_buffer_handle_t const*, void**, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, void**, unsigned long long*)
Line
Count
Source
509
2.42k
      tiledb_ctx_handle_t* ctx, Args... args) {
510
2.42k
    tiledb::api::ExceptionActionCtx action{ctx};
511
2.42k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
2.42k
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_buffer_set_data(tiledb_buffer_handle_t*, void*, unsigned long long)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_buffer_handle_t*, void*, unsigned long long)
Line
Count
Source
509
2.42k
      tiledb_ctx_handle_t* ctx, Args... args) {
510
2.42k
    tiledb::api::ExceptionActionCtx action{ctx};
511
2.42k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
2.42k
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_get_type(tiledb_filter_handle_t*, tiledb_filter_type_t*)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_filter_handle_t*, tiledb_filter_type_t*)
Line
Count
Source
509
64
      tiledb_ctx_handle_t* ctx, Args... args) {
510
64
    tiledb::api::ExceptionActionCtx action{ctx};
511
64
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
64
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_set_option(tiledb_filter_handle_t*, tiledb_filter_option_t, void const*)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_filter_handle_t*, tiledb_filter_option_t, void const*)
Line
Count
Source
509
1.07k
      tiledb_ctx_handle_t* ctx, Args... args) {
510
1.07k
    tiledb::api::ExceptionActionCtx action{ctx};
511
1.07k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
1.07k
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_get_option(tiledb_filter_handle_t*, tiledb_filter_option_t, void*)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_filter_handle_t*, tiledb_filter_option_t, void*)
Line
Count
Source
509
23
      tiledb_ctx_handle_t* ctx, Args... args) {
510
23
    tiledb::api::ExceptionActionCtx action{ctx};
511
23
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
23
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_list_add_filter(tiledb_filter_list_handle_t*, tiledb_filter_handle_t*)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_filter_list_handle_t*, tiledb_filter_handle_t*)
Line
Count
Source
509
3.25k
      tiledb_ctx_handle_t* ctx, Args... args) {
510
3.25k
    tiledb::api::ExceptionActionCtx action{ctx};
511
3.25k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
3.25k
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_list_set_max_chunk_size(tiledb_filter_list_handle_t*, unsigned int)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_filter_list_handle_t*, unsigned int)
Line
Count
Source
509
5
      tiledb_ctx_handle_t* ctx, Args... args) {
510
5
    tiledb::api::ExceptionActionCtx action{ctx};
511
5
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
5
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_list_get_nfilters(tiledb_filter_list_handle_t const*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_filter_list_handle_t const*, unsigned int*)
Line
Count
Source
509
83
      tiledb_ctx_handle_t* ctx, Args... args) {
510
83
    tiledb::api::ExceptionActionCtx action{ctx};
511
83
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
83
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_list_get_filter_from_index(tiledb_filter_list_handle_t const*, unsigned int, tiledb_filter_handle_t**)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_filter_list_handle_t const*, unsigned int, tiledb_filter_handle_t**)
Line
Count
Source
509
73
      tiledb_ctx_handle_t* ctx, Args... args) {
510
73
    tiledb::api::ExceptionActionCtx action{ctx};
511
73
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
73
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_filter_list_get_max_chunk_size(tiledb_filter_list_handle_t const*, unsigned int*)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_filter_list_handle_t const*, unsigned int*)
Line
Count
Source
509
30
      tiledb_ctx_handle_t* ctx, Args... args) {
510
30
    tiledb::api::ExceptionActionCtx action{ctx};
511
30
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
30
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_open(tiledb_group_handle_t*, tiledb_query_type_t)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_group_handle_t*, tiledb_query_type_t)
Line
Count
Source
509
127
      tiledb_ctx_handle_t* ctx, Args... args) {
510
127
    tiledb::api::ExceptionActionCtx action{ctx};
511
127
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
127
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_close(tiledb_group_handle_t*)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_group_handle_t*)
Line
Count
Source
509
123
      tiledb_ctx_handle_t* ctx, Args... args) {
510
123
    tiledb::api::ExceptionActionCtx action{ctx};
511
123
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
123
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_set_config(tiledb_group_handle_t*, tiledb_config_handle_t*)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_group_handle_t*, tiledb_config_handle_t*)
Line
Count
Source
509
74
      tiledb_ctx_handle_t* ctx, Args... args) {
510
74
    tiledb::api::ExceptionActionCtx action{ctx};
511
74
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
74
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_config(tiledb_group_handle_t*, tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_group_handle_t*, tiledb_config_handle_t**)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_put_metadata(tiledb_group_handle_t*, char const*, tiledb_datatype_t, unsigned int, void const*)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_group_handle_t*, char const*, tiledb_datatype_t, unsigned int, void const*)
Line
Count
Source
509
32
      tiledb_ctx_handle_t* ctx, Args... args) {
510
32
    tiledb::api::ExceptionActionCtx action{ctx};
511
32
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
32
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_delete_group(tiledb_group_handle_t*, char const*, unsigned char)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_group_handle_t*, char const*, unsigned char)
Line
Count
Source
509
6
      tiledb_ctx_handle_t* ctx, Args... args) {
510
6
    tiledb::api::ExceptionActionCtx action{ctx};
511
6
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
6
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_delete_metadata(tiledb_group_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_group_handle_t*, char const*)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_metadata(tiledb_group_handle_t*, char const*, tiledb_datatype_t*, unsigned int*, void const**)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_group_handle_t*, char const*, tiledb_datatype_t*, unsigned int*, void const**)
Line
Count
Source
509
7
      tiledb_ctx_handle_t* ctx, Args... args) {
510
7
    tiledb::api::ExceptionActionCtx action{ctx};
511
7
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
7
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_metadata_num(tiledb_group_handle_t*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_group_handle_t*, unsigned long long*)
Line
Count
Source
509
2
      tiledb_ctx_handle_t* ctx, Args... args) {
510
2
    tiledb::api::ExceptionActionCtx action{ctx};
511
2
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
2
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_metadata_from_index(tiledb_group_handle_t*, unsigned long long, char const**, unsigned int*, tiledb_datatype_t*, unsigned int*, void const**)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_group_handle_t*, unsigned long long, char const**, unsigned int*, tiledb_datatype_t*, unsigned int*, void const**)
Line
Count
Source
509
5
      tiledb_ctx_handle_t* ctx, Args... args) {
510
5
    tiledb::api::ExceptionActionCtx action{ctx};
511
5
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
5
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_has_metadata_key(tiledb_group_handle_t*, char const*, tiledb_datatype_t*, int*)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_group_handle_t*, char const*, tiledb_datatype_t*, int*)
Line
Count
Source
509
4
      tiledb_ctx_handle_t* ctx, Args... args) {
510
4
    tiledb::api::ExceptionActionCtx action{ctx};
511
4
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
4
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_add_member(tiledb_group_handle_t*, char const*, unsigned char, char const*)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_group_handle_t*, char const*, unsigned char, char const*)
Line
Count
Source
509
42
      tiledb_ctx_handle_t* ctx, Args... args) {
510
42
    tiledb::api::ExceptionActionCtx action{ctx};
511
42
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
42
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_remove_member(tiledb_group_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_group_handle_t*, char const*)
Line
Count
Source
509
18
      tiledb_ctx_handle_t* ctx, Args... args) {
510
18
    tiledb::api::ExceptionActionCtx action{ctx};
511
18
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
18
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_member_count(tiledb_group_handle_t*, unsigned long long*)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_group_handle_t*, unsigned long long*)
Line
Count
Source
509
45
      tiledb_ctx_handle_t* ctx, Args... args) {
510
45
    tiledb::api::ExceptionActionCtx action{ctx};
511
45
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
45
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_member_by_index(tiledb_group_handle_t*, unsigned long long, char**, tiledb_object_t*, char**)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_group_handle_t*, unsigned long long, char**, tiledb_object_t*, char**)
Line
Count
Source
509
69
      tiledb_ctx_handle_t* ctx, Args... args) {
510
69
    tiledb::api::ExceptionActionCtx action{ctx};
511
69
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
69
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_member_by_name(tiledb_group_handle_t*, char const*, char**, tiledb_object_t*)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_group_handle_t*, char const*, char**, tiledb_object_t*)
Line
Count
Source
509
2
      tiledb_ctx_handle_t* ctx, Args... args) {
510
2
    tiledb::api::ExceptionActionCtx action{ctx};
511
2
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
2
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_is_relative_uri_by_name(tiledb_group_handle_t*, char const*, unsigned char*)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_group_handle_t*, char const*, unsigned char*)
Line
Count
Source
509
13
      tiledb_ctx_handle_t* ctx, Args... args) {
510
13
    tiledb::api::ExceptionActionCtx action{ctx};
511
13
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
13
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_is_open(tiledb_group_handle_t*, int*)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_group_handle_t*, int*)
Line
Count
Source
509
16
      tiledb_ctx_handle_t* ctx, Args... args) {
510
16
    tiledb::api::ExceptionActionCtx action{ctx};
511
16
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
16
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_uri(tiledb_group_handle_t*, char const**)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_group_handle_t*, char const**)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_get_query_type(tiledb_group_handle_t*, tiledb_query_type_t*)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_group_handle_t*, tiledb_query_type_t*)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_group_dump_str(tiledb_group_handle_t*, char**, unsigned char)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_group_handle_t*, char**, unsigned char)
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_group(tiledb_group_handle_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_group_handle_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)
Line
Count
Source
509
4
      tiledb_ctx_handle_t* ctx, Args... args) {
510
4
    tiledb::api::ExceptionActionCtx action{ctx};
511
4
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
4
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_group(tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_group_handle_t*)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_group_handle_t*)
Line
Count
Source
509
4
      tiledb_ctx_handle_t* ctx, Args... args) {
510
4
    tiledb::api::ExceptionActionCtx action{ctx};
511
4
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
4
  }
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_serialize_group_metadata(tiledb_group_handle_t const*, tiledb_serialization_type_t, tiledb_buffer_handle_t**)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_group_handle_t const*, tiledb_serialization_type_t, tiledb_buffer_handle_t**)
Unexecuted instantiation: tiledb::api::CAPIFunction<&(tiledb::api::tiledb_deserialize_group_metadata(tiledb_group_handle_t*, tiledb_serialization_type_t, tiledb_buffer_handle_t const*)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, tiledb_group_handle_t*, tiledb_serialization_type_t, tiledb_buffer_handle_t const*)
tiledb::api::CAPIFunction<&(tf_assign(int, int*)), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*, int, int*)
Line
Count
Source
509
1
      tiledb_ctx_handle_t* ctx, Args... args) {
510
1
    tiledb::api::ExceptionActionCtx action{ctx};
511
1
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
1
  }
tiledb::api::CAPIFunction<&(tf_always_throw()), tiledb::api::detail::ExceptionActionDetailErr>::function_context(tiledb_ctx_handle_t*)
Line
Count
Source
509
1
      tiledb_ctx_handle_t* ctx, Args... args) {
510
1
    tiledb::api::ExceptionActionCtx action{ctx};
511
1
    return CAPIFunction<f, ExceptionActionCtx>::function(action, args...);
512
1
  }
513
514
  /**
515
   * Wrapper function for interface functions with an error argument but whose
516
   * corresponding implementation functions do not need one.
517
   *
518
   * @param error Object to receive any error message
519
   * @param args Arguments forwarded from API function
520
   * @return The return value of the call to the implementation function.
521
   */
522
  inline static capi_return_t function_error(
523
40.1k
      tiledb_error_handle_t** error, Args... args) {
524
40.1k
    ExceptionActionErr action{error};
525
40.1k
    return function(action, args...);
526
40.1k
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_alloc(tiledb_config_handle_t**)), tiledb::api::detail::ExceptionActionDetailErr>::function_error(tiledb_error_handle_t**, tiledb_config_handle_t**)
Line
Count
Source
523
16.8k
      tiledb_error_handle_t** error, Args... args) {
524
16.8k
    ExceptionActionErr action{error};
525
16.8k
    return function(action, args...);
526
16.8k
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_set(tiledb_config_handle_t*, char const*, char const*)), tiledb::api::detail::ExceptionActionDetailErr>::function_error(tiledb_error_handle_t**, tiledb_config_handle_t*, char const*, char const*)
Line
Count
Source
523
21.8k
      tiledb_error_handle_t** error, Args... args) {
524
21.8k
    ExceptionActionErr action{error};
525
21.8k
    return function(action, args...);
526
21.8k
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_get(tiledb_config_handle_t*, char const*, char const**)), tiledb::api::detail::ExceptionActionDetailErr>::function_error(tiledb_error_handle_t**, tiledb_config_handle_t*, char const*, char const**)
Line
Count
Source
523
137
      tiledb_error_handle_t** error, Args... args) {
524
137
    ExceptionActionErr action{error};
525
137
    return function(action, args...);
526
137
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_unset(tiledb_config_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailErr>::function_error(tiledb_error_handle_t**, tiledb_config_handle_t*, char const*)
Line
Count
Source
523
8
      tiledb_error_handle_t** error, Args... args) {
524
8
    ExceptionActionErr action{error};
525
8
    return function(action, args...);
526
8
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_load_from_file(tiledb_config_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailErr>::function_error(tiledb_error_handle_t**, tiledb_config_handle_t*, char const*)
Line
Count
Source
523
7
      tiledb_error_handle_t** error, Args... args) {
524
7
    ExceptionActionErr action{error};
525
7
    return function(action, args...);
526
7
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_save_to_file(tiledb_config_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailErr>::function_error(tiledb_error_handle_t**, tiledb_config_handle_t*, char const*)
Line
Count
Source
523
4
      tiledb_error_handle_t** error, Args... args) {
524
4
    ExceptionActionErr action{error};
525
4
    return function(action, args...);
526
4
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_iter_alloc(tiledb_config_handle_t*, char const*, tiledb_config_iter_handle_t**)), tiledb::api::detail::ExceptionActionDetailErr>::function_error(tiledb_error_handle_t**, tiledb_config_handle_t*, char const*, tiledb_config_iter_handle_t**)
Line
Count
Source
523
29
      tiledb_error_handle_t** error, Args... args) {
524
29
    ExceptionActionErr action{error};
525
29
    return function(action, args...);
526
29
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_iter_reset(tiledb_config_handle_t*, tiledb_config_iter_handle_t*, char const*)), tiledb::api::detail::ExceptionActionDetailErr>::function_error(tiledb_error_handle_t**, tiledb_config_handle_t*, tiledb_config_iter_handle_t*, char const*)
Line
Count
Source
523
4
      tiledb_error_handle_t** error, Args... args) {
524
4
    ExceptionActionErr action{error};
525
4
    return function(action, args...);
526
4
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_iter_here(tiledb_config_iter_handle_t*, char const**, char const**)), tiledb::api::detail::ExceptionActionDetailErr>::function_error(tiledb_error_handle_t**, tiledb_config_iter_handle_t*, char const**, char const**)
Line
Count
Source
523
421
      tiledb_error_handle_t** error, Args... args) {
524
421
    ExceptionActionErr action{error};
525
421
    return function(action, args...);
526
421
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_iter_next(tiledb_config_iter_handle_t*)), tiledb::api::detail::ExceptionActionDetailErr>::function_error(tiledb_error_handle_t**, tiledb_config_iter_handle_t*)
Line
Count
Source
523
417
      tiledb_error_handle_t** error, Args... args) {
524
417
    ExceptionActionErr action{error};
525
417
    return function(action, args...);
526
417
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_config_iter_done(tiledb_config_iter_handle_t*, int*)), tiledb::api::detail::ExceptionActionDetailErr>::function_error(tiledb_error_handle_t**, tiledb_config_iter_handle_t*, int*)
Line
Count
Source
523
427
      tiledb_error_handle_t** error, Args... args) {
524
427
    ExceptionActionErr action{error};
525
427
    return function(action, args...);
526
427
  }
tiledb::api::CAPIFunction<&(tiledb::api::tiledb_ctx_alloc(tiledb_config_handle_t*, tiledb_ctx_handle_t**)), tiledb::api::detail::ExceptionActionDetailErr>::function_error(tiledb_error_handle_t**, tiledb_config_handle_t*, tiledb_ctx_handle_t**)
Line
Count
Source
523
2
      tiledb_error_handle_t** error, Args... args) {
524
2
    ExceptionActionErr action{error};
525
2
    return function(action, args...);
526
2
  }
tiledb::api::CAPIFunction<&(tf_assign(int, int*)), tiledb::api::detail::ExceptionActionDetailErr>::function_error(tiledb_error_handle_t**, int, int*)
Line
Count
Source
523
1
      tiledb_error_handle_t** error, Args... args) {
524
1
    ExceptionActionErr action{error};
525
1
    return function(action, args...);
526
1
  }
tiledb::api::CAPIFunction<&(tf_always_throw()), tiledb::api::detail::ExceptionActionDetailErr>::function_error(tiledb_error_handle_t**)
Line
Count
Source
523
1
      tiledb_error_handle_t** error, Args... args) {
524
1
    ExceptionActionErr action{error};
525
1
    return function(action, args...);
526
1
  }
527
};
528
529
/*
530
 * `class CAPIFunction` is the foundation for a set of function transformers
531
 * that convert API implementation functions into API interface functions. We
532
 * have five such function transformers:
533
 * - api_entry_plain: Just does the transformation and nothing else.
534
 * - api_entry_void: Similar to _plain, it removes the return value.
535
 * - api_entry_with_context: Uses an initial context argument to return error
536
 *     messages.
537
 * - api_entry_context: Adds a context argument to those of the implementation
538
 *     function and returns error messages through it.
539
 * - api_entry_error: Adds an error argument to those of the implementation
540
 *     function and returns error messages through it.
541
 *
542
 * `api_entry_with_context` is primarily used to wrap old code that still does
543
 * manual error returns through its context argument. It's usually the case that
544
 * the only use of a context argument is for error returns. In such cases the
545
 * implementation function can be rewritten without it and the wrapper changed
546
 * to `api_entry_context`.
547
 */
548
549
/**
550
 * Plain API function transformer keeps the signature intact.
551
 *
552
 * @tparam f An API implementation function
553
 */
554
template <auto f>
555
constexpr auto api_entry_plain =
556
    CAPIFunction<f, ExceptionAction>::function_plain;
557
558
/**
559
 * Declaration only defined through a specialization.
560
 *
561
 * @tparam f An API implementation function
562
 */
563
template <auto f>
564
struct CAPIFunctionVoid;
565
566
/**
567
 * Wrapper class for API implementation functions with `void` return.
568
 *
569
 * We require a separate wrapper class here so we can match the template
570
 * argument `f` to a function with void return, since `CAPIFunction` only
571
 * matches those that return `capi_return_t`.
572
 *
573
 * @tparam Args Argument types for the function
574
 * @tparam f An API implementation function
575
 */
576
template <class... Args, void (*f)(Args...)>
577
struct CAPIFunctionVoid<f> {
578
  /**
579
   * Function transformer changes an API implementation function with `void`
580
   * return to one returning a (trivially constant) `capi_return_t` value.
581
   *
582
   * This function is used to match the function signature in `CAPIFunction`,
583
   * which requires a return value. This allows us to reuse its wrapper function
584
   * without duplicating code.
585
   *
586
   * @param args Arguments passed to the function
587
   * @return TILEDB_OK
588
   */
589
252k
  inline static capi_return_t function_from_void(Args... args) {
590
252k
    f(args...);
591
252k
    return TILEDB_OK;
592
252k
  }
tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_buffer_list_free(tiledb_buffer_list_t**))>::function_from_void(tiledb_buffer_list_t**)
Line
Count
Source
589
2.42k
  inline static capi_return_t function_from_void(Args... args) {
590
2.42k
    f(args...);
591
2.42k
    return TILEDB_OK;
592
2.42k
  }
tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_attribute_free(tiledb_attribute_t**))>::function_from_void(tiledb_attribute_t**)
Line
Count
Source
589
20.6k
  inline static capi_return_t function_from_void(Args... args) {
590
20.6k
    f(args...);
591
20.6k
    return TILEDB_OK;
592
20.6k
  }
tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_domain_free(tiledb_domain_t**))>::function_from_void(tiledb_domain_t**)
Line
Count
Source
589
29.1k
  inline static capi_return_t function_from_void(Args... args) {
590
29.1k
    f(args...);
591
29.1k
    return TILEDB_OK;
592
29.1k
  }
tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_dimension_free(tiledb_dimension_t**))>::function_from_void(tiledb_dimension_t**)
Line
Count
Source
589
27.2k
  inline static capi_return_t function_from_void(Args... args) {
590
27.2k
    f(args...);
591
27.2k
    return TILEDB_OK;
592
27.2k
  }
tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_array_schema_free(tiledb_array_schema_t**))>::function_from_void(tiledb_array_schema_t**)
Line
Count
Source
589
58.1k
  inline static capi_return_t function_from_void(Args... args) {
590
58.1k
    f(args...);
591
58.1k
    return TILEDB_OK;
592
58.1k
  }
tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_array_schema_evolution_free(tiledb_array_schema_evolution_t**))>::function_from_void(tiledb_array_schema_evolution_t**)
Line
Count
Source
589
13
  inline static capi_return_t function_from_void(Args... args) {
590
13
    f(args...);
591
13
    return TILEDB_OK;
592
13
  }
tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_query_free(tiledb_query_t**))>::function_from_void(tiledb_query_t**)
Line
Count
Source
589
27.9k
  inline static capi_return_t function_from_void(Args... args) {
590
27.9k
    f(args...);
591
27.9k
    return TILEDB_OK;
592
27.9k
  }
tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_subarray_free(tiledb_subarray_t**))>::function_from_void(tiledb_subarray_t**)
Line
Count
Source
589
4.22k
  inline static capi_return_t function_from_void(Args... args) {
590
4.22k
    f(args...);
591
4.22k
    return TILEDB_OK;
592
4.22k
  }
tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_query_condition_free(tiledb_query_condition_t**))>::function_from_void(tiledb_query_condition_t**)
Line
Count
Source
589
9.35k
  inline static capi_return_t function_from_void(Args... args) {
590
9.35k
    f(args...);
591
9.35k
    return TILEDB_OK;
592
9.35k
  }
tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_array_free(tiledb_array_t**))>::function_from_void(tiledb_array_t**)
Line
Count
Source
589
28.7k
  inline static capi_return_t function_from_void(Args... args) {
590
28.7k
    f(args...);
591
28.7k
    return TILEDB_OK;
592
28.7k
  }
tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_vfs_free(tiledb_vfs_t**))>::function_from_void(tiledb_vfs_t**)
Line
Count
Source
589
5.32k
  inline static capi_return_t function_from_void(Args... args) {
590
5.32k
    f(args...);
591
5.32k
    return TILEDB_OK;
592
5.32k
  }
tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_vfs_fh_free(tiledb_vfs_fh_t**))>::function_from_void(tiledb_vfs_fh_t**)
Line
Count
Source
589
86
  inline static capi_return_t function_from_void(Args... args) {
590
86
    f(args...);
591
86
    return TILEDB_OK;
592
86
  }
tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_fragment_info_free(tiledb_fragment_info_t**))>::function_from_void(tiledb_fragment_info_t**)
Line
Count
Source
589
113
  inline static capi_return_t function_from_void(Args... args) {
590
113
    f(args...);
591
113
    return TILEDB_OK;
592
113
  }
tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_consolidation_plan_free(tiledb_consolidation_plan_t**))>::function_from_void(tiledb_consolidation_plan_t**)
Line
Count
Source
589
12
  inline static capi_return_t function_from_void(Args... args) {
590
12
    f(args...);
591
12
    return TILEDB_OK;
592
12
  }
tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_buffer_free(tiledb_buffer_handle_t**))>::function_from_void(tiledb_buffer_handle_t**)
Line
Count
Source
589
5.00k
  inline static capi_return_t function_from_void(Args... args) {
590
5.00k
    f(args...);
591
5.00k
    return TILEDB_OK;
592
5.00k
  }
tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_error_free(tiledb_error_handle_t**))>::function_from_void(tiledb_error_handle_t**)
Line
Count
Source
589
290
  inline static capi_return_t function_from_void(Args... args) {
590
290
    f(args...);
591
290
    return TILEDB_OK;
592
290
  }
tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_config_free(tiledb_config_handle_t**))>::function_from_void(tiledb_config_handle_t**)
Line
Count
Source
589
17.6k
  inline static capi_return_t function_from_void(Args... args) {
590
17.6k
    f(args...);
591
17.6k
    return TILEDB_OK;
592
17.6k
  }
tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_config_iter_free(tiledb_config_iter_handle_t**))>::function_from_void(tiledb_config_iter_handle_t**)
Line
Count
Source
589
27
  inline static capi_return_t function_from_void(Args... args) {
590
27
    f(args...);
591
27
    return TILEDB_OK;
592
27
  }
tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_ctx_free(tiledb_ctx_handle_t**))>::function_from_void(tiledb_ctx_handle_t**)
Line
Count
Source
589
9.67k
  inline static capi_return_t function_from_void(Args... args) {
590
9.67k
    f(args...);
591
9.67k
    return TILEDB_OK;
592
9.67k
  }
tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_filter_free(tiledb_filter_handle_t**))>::function_from_void(tiledb_filter_handle_t**)
Line
Count
Source
589
3.32k
  inline static capi_return_t function_from_void(Args... args) {
590
3.32k
    f(args...);
591
3.32k
    return TILEDB_OK;
592
3.32k
  }
tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_filter_list_free(tiledb_filter_list_handle_t**))>::function_from_void(tiledb_filter_list_handle_t**)
Line
Count
Source
589
3.27k
  inline static capi_return_t function_from_void(Args... args) {
590
3.27k
    f(args...);
591
3.27k
    return TILEDB_OK;
592
3.27k
  }
tiledb::api::CAPIFunctionVoid<&(tiledb::api::tiledb_group_free(tiledb_group_handle_t**))>::function_from_void(tiledb_group_handle_t**)
Line
Count
Source
589
47
  inline static capi_return_t function_from_void(Args... args) {
590
47
    f(args...);
591
47
    return TILEDB_OK;
592
47
  }
tiledb::api::CAPIFunctionVoid<&(tf_void_assign(int, int*))>::function_from_void(int, int*)
Line
Count
Source
589
1
  inline static capi_return_t function_from_void(Args... args) {
590
1
    f(args...);
591
1
    return TILEDB_OK;
592
1
  }
tiledb::api::CAPIFunctionVoid<&(tf_void_throw())>::function_from_void()
Line
Count
Source
589
1
  inline static capi_return_t function_from_void(Args... args) {
590
1
    f(args...);
591
1
    return TILEDB_OK;
592
1
  }
593
};
594
595
/**
596
 * Function transformer changes an API implementation function with `void`
597
 * return to an API interface function, also with `void` return.
598
 *
599
 * @tparam f An implementation function.
600
 */
601
template <auto f>
602
constexpr auto api_entry_void = CAPIFunction<
603
    CAPIFunctionVoid<f>::function_from_void,
604
    tiledb::api::ExceptionAction>::void_function;
605
606
/**
607
 * Declaration only defined through a specialization.
608
 *
609
 * @tparam f An API implementation function
610
 */
611
template <auto f>
612
struct CAPIFunctionContext;
613
614
/**
615
 * Wrapper class for API implementation functions with a leading context
616
 * argument.
617
 *
618
 * @tparam Args Arguments of the implementation following the initial context
619
 * @tparam f An API implementation function
620
 */
621
template <class... Args, capi_return_t (*f)(tiledb_ctx_handle_t*, Args...)>
622
struct CAPIFunctionContext<f> : CAPIFunction<f, ExceptionActionCtx> {
623
  inline static capi_return_t function_with_context(
624
4.65M
      tiledb_ctx_handle_t* ctx, Args... args) {
625
4.65M
    tiledb::api::ExceptionActionCtx action{ctx};
626
4.65M
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
4.65M
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_buffer_list_alloc(tiledb_ctx_handle_t*, tiledb_buffer_list_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_buffer_list_t**)
Line
Count
Source
624
2
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2
    tiledb::api::ExceptionActionCtx action{ctx};
626
2
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_buffer_list_get_num_buffers(tiledb_ctx_handle_t*, tiledb_buffer_list_t const*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_buffer_list_t const*, unsigned long long*)
Line
Count
Source
624
2
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2
    tiledb::api::ExceptionActionCtx action{ctx};
626
2
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_buffer_list_get_buffer(tiledb_ctx_handle_t*, tiledb_buffer_list_t const*, unsigned long long, tiledb_buffer_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_buffer_list_t const*, unsigned long long, tiledb_buffer_handle_t**)
Line
Count
Source
624
4
      tiledb_ctx_handle_t* ctx, Args... args) {
625
4
    tiledb::api::ExceptionActionCtx action{ctx};
626
4
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
4
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_buffer_list_get_total_size(tiledb_ctx_handle_t*, tiledb_buffer_list_t const*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_buffer_list_t const*, unsigned long long*)
Line
Count
Source
624
2
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2
    tiledb::api::ExceptionActionCtx action{ctx};
626
2
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_buffer_list_flatten(tiledb_ctx_handle_t*, tiledb_buffer_list_t const*, tiledb_buffer_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_buffer_list_t const*, tiledb_buffer_handle_t**)
Line
Count
Source
624
2.42k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2.42k
    tiledb::api::ExceptionActionCtx action{ctx};
626
2.42k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2.42k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_attribute_alloc(tiledb_ctx_handle_t*, char const*, tiledb_datatype_t, tiledb_attribute_t**))>::function_with_context(tiledb_ctx_handle_t*, char const*, tiledb_datatype_t, tiledb_attribute_t**)
Line
Count
Source
624
15.9k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
15.9k
    tiledb::api::ExceptionActionCtx action{ctx};
626
15.9k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
15.9k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_attribute_set_nullable(tiledb_ctx_handle_t*, tiledb_attribute_t*, unsigned char))>::function_with_context(tiledb_ctx_handle_t*, tiledb_attribute_t*, unsigned char)
Line
Count
Source
624
6.17k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
6.17k
    tiledb::api::ExceptionActionCtx action{ctx};
626
6.17k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
6.17k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_attribute_set_filter_list(tiledb_ctx_handle_t*, tiledb_attribute_t*, tiledb_filter_list_handle_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_attribute_t*, tiledb_filter_list_handle_t*)
Line
Count
Source
624
2.52k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2.52k
    tiledb::api::ExceptionActionCtx action{ctx};
626
2.52k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2.52k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_attribute_set_cell_val_num(tiledb_ctx_handle_t*, tiledb_attribute_t*, unsigned int))>::function_with_context(tiledb_ctx_handle_t*, tiledb_attribute_t*, unsigned int)
Line
Count
Source
624
15.6k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
15.6k
    tiledb::api::ExceptionActionCtx action{ctx};
626
15.6k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
15.6k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_attribute_get_name(tiledb_ctx_handle_t*, tiledb_attribute_t const*, char const**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_attribute_t const*, char const**)
Line
Count
Source
624
230
      tiledb_ctx_handle_t* ctx, Args... args) {
625
230
    tiledb::api::ExceptionActionCtx action{ctx};
626
230
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
230
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_attribute_get_type(tiledb_ctx_handle_t*, tiledb_attribute_t const*, tiledb_datatype_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_attribute_t const*, tiledb_datatype_t*)
Line
Count
Source
624
389
      tiledb_ctx_handle_t* ctx, Args... args) {
625
389
    tiledb::api::ExceptionActionCtx action{ctx};
626
389
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
389
  }
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_attribute_get_nullable(tiledb_ctx_handle_t*, tiledb_attribute_t*, unsigned char*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_attribute_t*, unsigned char*)
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_attribute_get_filter_list(tiledb_ctx_handle_t*, tiledb_attribute_t*, tiledb_filter_list_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_attribute_t*, tiledb_filter_list_handle_t**)
Line
Count
Source
624
14
      tiledb_ctx_handle_t* ctx, Args... args) {
625
14
    tiledb::api::ExceptionActionCtx action{ctx};
626
14
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
14
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_attribute_get_cell_val_num(tiledb_ctx_handle_t*, tiledb_attribute_t const*, unsigned int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_attribute_t const*, unsigned int*)
Line
Count
Source
624
4.30k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
4.30k
    tiledb::api::ExceptionActionCtx action{ctx};
626
4.30k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
4.30k
  }
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_attribute_get_cell_size(tiledb_ctx_handle_t*, tiledb_attribute_t const*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_attribute_t const*, unsigned long long*)
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_attribute_dump(tiledb_ctx_handle_t*, tiledb_attribute_t const*, __sFILE*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_attribute_t const*, __sFILE*)
Line
Count
Source
624
18
      tiledb_ctx_handle_t* ctx, Args... args) {
625
18
    tiledb::api::ExceptionActionCtx action{ctx};
626
18
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
18
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_attribute_set_fill_value(tiledb_ctx_handle_t*, tiledb_attribute_t*, void const*, unsigned long long))>::function_with_context(tiledb_ctx_handle_t*, tiledb_attribute_t*, void const*, unsigned long long)
Line
Count
Source
624
82
      tiledb_ctx_handle_t* ctx, Args... args) {
625
82
    tiledb::api::ExceptionActionCtx action{ctx};
626
82
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
82
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_attribute_get_fill_value(tiledb_ctx_handle_t*, tiledb_attribute_t*, void const**, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_attribute_t*, void const**, unsigned long long*)
Line
Count
Source
624
16
      tiledb_ctx_handle_t* ctx, Args... args) {
625
16
    tiledb::api::ExceptionActionCtx action{ctx};
626
16
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
16
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_attribute_set_fill_value_nullable(tiledb_ctx_handle_t*, tiledb_attribute_t*, void const*, unsigned long long, unsigned char))>::function_with_context(tiledb_ctx_handle_t*, tiledb_attribute_t*, void const*, unsigned long long, unsigned char)
Line
Count
Source
624
41
      tiledb_ctx_handle_t* ctx, Args... args) {
625
41
    tiledb::api::ExceptionActionCtx action{ctx};
626
41
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
41
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_attribute_get_fill_value_nullable(tiledb_ctx_handle_t*, tiledb_attribute_t*, void const**, unsigned long long*, unsigned char*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_attribute_t*, void const**, unsigned long long*, unsigned char*)
Line
Count
Source
624
8
      tiledb_ctx_handle_t* ctx, Args... args) {
625
8
    tiledb::api::ExceptionActionCtx action{ctx};
626
8
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
8
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_domain_alloc(tiledb_ctx_handle_t*, tiledb_domain_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_domain_t**)
Line
Count
Source
624
9.39k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
9.39k
    tiledb::api::ExceptionActionCtx action{ctx};
626
9.39k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
9.39k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_domain_get_type(tiledb_ctx_handle_t*, tiledb_domain_t const*, tiledb_datatype_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_domain_t const*, tiledb_datatype_t*)
Line
Count
Source
624
545
      tiledb_ctx_handle_t* ctx, Args... args) {
625
545
    tiledb::api::ExceptionActionCtx action{ctx};
626
545
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
545
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_domain_get_ndim(tiledb_ctx_handle_t*, tiledb_domain_t const*, unsigned int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_domain_t const*, unsigned int*)
Line
Count
Source
624
474
      tiledb_ctx_handle_t* ctx, Args... args) {
625
474
    tiledb::api::ExceptionActionCtx action{ctx};
626
474
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
474
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_domain_add_dimension(tiledb_ctx_handle_t*, tiledb_domain_t*, tiledb_dimension_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_domain_t*, tiledb_dimension_t*)
Line
Count
Source
624
17.9k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
17.9k
    tiledb::api::ExceptionActionCtx action{ctx};
626
17.9k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
17.9k
  }
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_domain_dump(tiledb_ctx_handle_t*, tiledb_domain_t const*, __sFILE*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_domain_t const*, __sFILE*)
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_dimension_alloc(tiledb_ctx_handle_t*, char const*, tiledb_datatype_t, void const*, void const*, tiledb_dimension_t**))>::function_with_context(tiledb_ctx_handle_t*, char const*, tiledb_datatype_t, void const*, void const*, tiledb_dimension_t**)
Line
Count
Source
624
17.9k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
17.9k
    tiledb::api::ExceptionActionCtx action{ctx};
626
17.9k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
17.9k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_dimension_set_filter_list(tiledb_ctx_handle_t*, tiledb_dimension_t*, tiledb_filter_list_handle_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_dimension_t*, tiledb_filter_list_handle_t*)
Line
Count
Source
624
88
      tiledb_ctx_handle_t* ctx, Args... args) {
625
88
    tiledb::api::ExceptionActionCtx action{ctx};
626
88
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
88
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_dimension_set_cell_val_num(tiledb_ctx_handle_t*, tiledb_dimension_t*, unsigned int))>::function_with_context(tiledb_ctx_handle_t*, tiledb_dimension_t*, unsigned int)
Line
Count
Source
624
16
      tiledb_ctx_handle_t* ctx, Args... args) {
625
16
    tiledb::api::ExceptionActionCtx action{ctx};
626
16
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
16
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_dimension_get_filter_list(tiledb_ctx_handle_t*, tiledb_dimension_t*, tiledb_filter_list_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_dimension_t*, tiledb_filter_list_handle_t**)
Line
Count
Source
624
4
      tiledb_ctx_handle_t* ctx, Args... args) {
625
4
    tiledb::api::ExceptionActionCtx action{ctx};
626
4
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
4
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_dimension_get_cell_val_num(tiledb_ctx_handle_t*, tiledb_dimension_t const*, unsigned int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_dimension_t const*, unsigned int*)
Line
Count
Source
624
5.10k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
5.10k
    tiledb::api::ExceptionActionCtx action{ctx};
626
5.10k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
5.10k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_dimension_get_name(tiledb_ctx_handle_t*, tiledb_dimension_t const*, char const**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_dimension_t const*, char const**)
Line
Count
Source
624
183
      tiledb_ctx_handle_t* ctx, Args... args) {
625
183
    tiledb::api::ExceptionActionCtx action{ctx};
626
183
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
183
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_dimension_get_type(tiledb_ctx_handle_t*, tiledb_dimension_t const*, tiledb_datatype_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_dimension_t const*, tiledb_datatype_t*)
Line
Count
Source
624
4.07k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
4.07k
    tiledb::api::ExceptionActionCtx action{ctx};
626
4.07k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
4.07k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_dimension_get_domain(tiledb_ctx_handle_t*, tiledb_dimension_t const*, void const**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_dimension_t const*, void const**)
Line
Count
Source
624
20
      tiledb_ctx_handle_t* ctx, Args... args) {
625
20
    tiledb::api::ExceptionActionCtx action{ctx};
626
20
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
20
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_dimension_get_tile_extent(tiledb_ctx_handle_t*, tiledb_dimension_t const*, void const**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_dimension_t const*, void const**)
Line
Count
Source
624
23
      tiledb_ctx_handle_t* ctx, Args... args) {
625
23
    tiledb::api::ExceptionActionCtx action{ctx};
626
23
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
23
  }
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_dimension_dump(tiledb_ctx_handle_t*, tiledb_dimension_t const*, __sFILE*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_dimension_t const*, __sFILE*)
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_domain_get_dimension_from_index(tiledb_ctx_handle_t*, tiledb_domain_t const*, unsigned int, tiledb_dimension_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_domain_t const*, unsigned int, tiledb_dimension_t**)
Line
Count
Source
624
1.01k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
1.01k
    tiledb::api::ExceptionActionCtx action{ctx};
626
1.01k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
1.01k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_domain_get_dimension_from_name(tiledb_ctx_handle_t*, tiledb_domain_t const*, char const*, tiledb_dimension_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_domain_t const*, char const*, tiledb_dimension_t**)
Line
Count
Source
624
8.33k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
8.33k
    tiledb::api::ExceptionActionCtx action{ctx};
626
8.33k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
8.33k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_domain_has_dimension(tiledb_ctx_handle_t*, tiledb_domain_t const*, char const*, int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_domain_t const*, char const*, int*)
Line
Count
Source
624
9.63k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
9.63k
    tiledb::api::ExceptionActionCtx action{ctx};
626
9.63k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
9.63k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_alloc(tiledb_ctx_handle_t*, tiledb_array_type_t, tiledb_array_schema_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_type_t, tiledb_array_schema_t**)
Line
Count
Source
624
9.39k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
9.39k
    tiledb::api::ExceptionActionCtx action{ctx};
626
9.39k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
9.39k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_add_attribute(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_attribute_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_attribute_t*)
Line
Count
Source
624
15.8k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
15.8k
    tiledb::api::ExceptionActionCtx action{ctx};
626
15.8k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
15.8k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_set_allows_dups(tiledb_ctx_handle_t*, tiledb_array_schema_t*, int))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t*, int)
Line
Count
Source
624
5.42k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
5.42k
    tiledb::api::ExceptionActionCtx action{ctx};
626
5.42k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
5.42k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_get_allows_dups(tiledb_ctx_handle_t*, tiledb_array_schema_t*, int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t*, int*)
Line
Count
Source
624
11
      tiledb_ctx_handle_t* ctx, Args... args) {
625
11
    tiledb::api::ExceptionActionCtx action{ctx};
626
11
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
11
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_get_version(tiledb_ctx_handle_t*, tiledb_array_schema_t*, unsigned int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t*, unsigned int*)
Line
Count
Source
624
4
      tiledb_ctx_handle_t* ctx, Args... args) {
625
4
    tiledb::api::ExceptionActionCtx action{ctx};
626
4
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
4
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_set_domain(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_domain_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_domain_t*)
Line
Count
Source
624
9.39k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
9.39k
    tiledb::api::ExceptionActionCtx action{ctx};
626
9.39k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
9.39k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_set_capacity(tiledb_ctx_handle_t*, tiledb_array_schema_t*, unsigned long long))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t*, unsigned long long)
Line
Count
Source
624
2.15k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2.15k
    tiledb::api::ExceptionActionCtx action{ctx};
626
2.15k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2.15k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_set_cell_order(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_layout_t))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_layout_t)
Line
Count
Source
624
7.76k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
7.76k
    tiledb::api::ExceptionActionCtx action{ctx};
626
7.76k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
7.76k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_set_tile_order(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_layout_t))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_layout_t)
Line
Count
Source
624
7.00k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
7.00k
    tiledb::api::ExceptionActionCtx action{ctx};
626
7.00k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
7.00k
  }
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_timestamp_range(tiledb_ctx_handle_t*, tiledb_array_schema_t*, unsigned long long*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t*, unsigned long long*, unsigned long long*)
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_set_coords_filter_list(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t*)
Line
Count
Source
624
629
      tiledb_ctx_handle_t* ctx, Args... args) {
625
629
    tiledb::api::ExceptionActionCtx action{ctx};
626
629
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
629
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_set_offsets_filter_list(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t*)
Line
Count
Source
624
7
      tiledb_ctx_handle_t* ctx, Args... args) {
625
7
    tiledb::api::ExceptionActionCtx action{ctx};
626
7
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
7
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_set_validity_filter_list(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t*)
Line
Count
Source
624
3
      tiledb_ctx_handle_t* ctx, Args... args) {
625
3
    tiledb::api::ExceptionActionCtx action{ctx};
626
3
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
3
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_check(tiledb_ctx_handle_t*, tiledb_array_schema_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t*)
Line
Count
Source
624
9.26k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
9.26k
    tiledb::api::ExceptionActionCtx action{ctx};
626
9.26k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
9.26k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_load(tiledb_ctx_handle_t*, char const*, tiledb_array_schema_t**))>::function_with_context(tiledb_ctx_handle_t*, char const*, tiledb_array_schema_t**)
Line
Count
Source
624
31
      tiledb_ctx_handle_t* ctx, Args... args) {
625
31
    tiledb::api::ExceptionActionCtx action{ctx};
626
31
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
31
  }
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_load_with_key(tiledb_ctx_handle_t*, char const*, tiledb_encryption_type_t, void const*, unsigned int, tiledb_array_schema_t**))>::function_with_context(tiledb_ctx_handle_t*, char const*, tiledb_encryption_type_t, void const*, unsigned int, tiledb_array_schema_t**)
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_get_array_type(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_array_type_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_array_type_t*)
Line
Count
Source
624
9
      tiledb_ctx_handle_t* ctx, Args... args) {
625
9
    tiledb::api::ExceptionActionCtx action{ctx};
626
9
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
9
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_get_capacity(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, unsigned long long*)
Line
Count
Source
624
3
      tiledb_ctx_handle_t* ctx, Args... args) {
625
3
    tiledb::api::ExceptionActionCtx action{ctx};
626
3
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
3
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_get_cell_order(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_layout_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_layout_t*)
Line
Count
Source
624
6
      tiledb_ctx_handle_t* ctx, Args... args) {
625
6
    tiledb::api::ExceptionActionCtx action{ctx};
626
6
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
6
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_get_coords_filter_list(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t**)
Line
Count
Source
624
7
      tiledb_ctx_handle_t* ctx, Args... args) {
625
7
    tiledb::api::ExceptionActionCtx action{ctx};
626
7
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
7
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_get_offsets_filter_list(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t**)
Line
Count
Source
624
6
      tiledb_ctx_handle_t* ctx, Args... args) {
625
6
    tiledb::api::ExceptionActionCtx action{ctx};
626
6
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
6
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_get_validity_filter_list(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t*, tiledb_filter_list_handle_t**)
Line
Count
Source
624
3
      tiledb_ctx_handle_t* ctx, Args... args) {
625
3
    tiledb::api::ExceptionActionCtx action{ctx};
626
3
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
3
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_get_domain(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_domain_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_domain_t**)
Line
Count
Source
624
19.7k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
19.7k
    tiledb::api::ExceptionActionCtx action{ctx};
626
19.7k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
19.7k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_get_tile_order(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_layout_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_layout_t*)
Line
Count
Source
624
4
      tiledb_ctx_handle_t* ctx, Args... args) {
625
4
    tiledb::api::ExceptionActionCtx action{ctx};
626
4
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
4
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_get_attribute_num(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, unsigned int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, unsigned int*)
Line
Count
Source
624
108
      tiledb_ctx_handle_t* ctx, Args... args) {
625
108
    tiledb::api::ExceptionActionCtx action{ctx};
626
108
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
108
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_dump(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, __sFILE*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, __sFILE*)
Line
Count
Source
624
11
      tiledb_ctx_handle_t* ctx, Args... args) {
625
11
    tiledb::api::ExceptionActionCtx action{ctx};
626
11
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
11
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_get_attribute_from_index(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, unsigned int, tiledb_attribute_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, unsigned int, tiledb_attribute_t**)
Line
Count
Source
624
224
      tiledb_ctx_handle_t* ctx, Args... args) {
625
224
    tiledb::api::ExceptionActionCtx action{ctx};
626
224
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
224
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_get_attribute_from_name(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, char const*, tiledb_attribute_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, char const*, tiledb_attribute_t**)
Line
Count
Source
624
4.51k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
4.51k
    tiledb::api::ExceptionActionCtx action{ctx};
626
4.51k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
4.51k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_has_attribute(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, char const*, int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, char const*, int*)
Line
Count
Source
624
10.6k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
10.6k
    tiledb::api::ExceptionActionCtx action{ctx};
626
10.6k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
10.6k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_evolution_alloc(tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t**)
Line
Count
Source
624
13
      tiledb_ctx_handle_t* ctx, Args... args) {
625
13
    tiledb::api::ExceptionActionCtx action{ctx};
626
13
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
13
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_evolution_add_attribute(tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t*, tiledb_attribute_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t*, tiledb_attribute_t*)
Line
Count
Source
624
37
      tiledb_ctx_handle_t* ctx, Args... args) {
625
37
    tiledb::api::ExceptionActionCtx action{ctx};
626
37
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
37
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_evolution_drop_attribute(tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t*, char const*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t*, char const*)
Line
Count
Source
624
5
      tiledb_ctx_handle_t* ctx, Args... args) {
625
5
    tiledb::api::ExceptionActionCtx action{ctx};
626
5
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
5
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_schema_evolution_set_timestamp_range(tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t*, unsigned long long, unsigned long long))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t*, unsigned long long, unsigned long long)
Line
Count
Source
624
13
      tiledb_ctx_handle_t* ctx, Args... args) {
625
13
    tiledb::api::ExceptionActionCtx action{ctx};
626
13
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
13
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_alloc(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t, tiledb_query_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t, tiledb_query_t**)
Line
Count
Source
624
27.9k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
27.9k
    tiledb::api::ExceptionActionCtx action{ctx};
626
27.9k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
27.9k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_stats(tiledb_ctx_handle_t*, tiledb_query_t*, char**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, char**)
Line
Count
Source
624
998
      tiledb_ctx_handle_t* ctx, Args... args) {
625
998
    tiledb::api::ExceptionActionCtx action{ctx};
626
998
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
998
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_set_config(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_config_handle_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_config_handle_t*)
Line
Count
Source
624
13
      tiledb_ctx_handle_t* ctx, Args... args) {
625
13
    tiledb::api::ExceptionActionCtx action{ctx};
626
13
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
13
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_config(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_config_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_config_handle_t**)
Line
Count
Source
624
1
      tiledb_ctx_handle_t* ctx, Args... args) {
625
1
    tiledb::api::ExceptionActionCtx action{ctx};
626
1
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
1
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_set_subarray(tiledb_ctx_handle_t*, tiledb_query_t*, void const*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, void const*)
Line
Count
Source
624
6.92k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
6.92k
    tiledb::api::ExceptionActionCtx action{ctx};
626
6.92k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
6.92k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_set_subarray_t(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_subarray_t const*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_subarray_t const*)
Line
Count
Source
624
4.25k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
4.25k
    tiledb::api::ExceptionActionCtx action{ctx};
626
4.25k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
4.25k
  }
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_set_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void*, unsigned long long*)
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_set_buffer_var(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long*, unsigned long long*, void*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long*, unsigned long long*, void*, unsigned long long*)
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_set_buffer_nullable(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void*, unsigned long long*, unsigned char*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void*, unsigned long long*, unsigned char*, unsigned long long*)
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_set_buffer_var_nullable(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long*, unsigned long long*, void*, unsigned long long*, unsigned char*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long*, unsigned long long*, void*, unsigned long long*, unsigned char*, unsigned long long*)
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_set_data_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void*, unsigned long long*)
Line
Count
Source
624
72.6k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
72.6k
    tiledb::api::ExceptionActionCtx action{ctx};
626
72.6k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
72.6k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_set_offsets_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long*, unsigned long long*)
Line
Count
Source
624
9.40k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
9.40k
    tiledb::api::ExceptionActionCtx action{ctx};
626
9.40k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
9.40k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_set_validity_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned char*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned char*, unsigned long long*)
Line
Count
Source
624
12.3k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
12.3k
    tiledb::api::ExceptionActionCtx action{ctx};
626
12.3k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
12.3k
  }
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void**, unsigned long long**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void**, unsigned long long**)
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_buffer_var(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long**, unsigned long long**, void**, unsigned long long**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long**, unsigned long long**, void**, unsigned long long**)
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_buffer_nullable(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void**, unsigned long long**, unsigned char**, unsigned long long**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void**, unsigned long long**, unsigned char**, unsigned long long**)
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_buffer_var_nullable(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long**, unsigned long long**, void**, unsigned long long**, unsigned char**, unsigned long long**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long**, unsigned long long**, void**, unsigned long long**, unsigned char**, unsigned long long**)
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_data_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void**, unsigned long long**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void**, unsigned long long**)
Line
Count
Source
624
540
      tiledb_ctx_handle_t* ctx, Args... args) {
625
540
    tiledb::api::ExceptionActionCtx action{ctx};
626
540
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
540
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_offsets_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long**, unsigned long long**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned long long**, unsigned long long**)
Line
Count
Source
624
99
      tiledb_ctx_handle_t* ctx, Args... args) {
625
99
    tiledb::api::ExceptionActionCtx action{ctx};
626
99
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
99
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_validity_buffer(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned char**, unsigned long long**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, unsigned char**, unsigned long long**)
Line
Count
Source
624
28
      tiledb_ctx_handle_t* ctx, Args... args) {
625
28
    tiledb::api::ExceptionActionCtx action{ctx};
626
28
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
28
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_set_layout(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_layout_t))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_layout_t)
Line
Count
Source
624
21.8k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
21.8k
    tiledb::api::ExceptionActionCtx action{ctx};
626
21.8k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
21.8k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_set_condition(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_query_condition_t const*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_query_condition_t const*)
Line
Count
Source
624
5.17k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
5.17k
    tiledb::api::ExceptionActionCtx action{ctx};
626
5.17k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
5.17k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_finalize(tiledb_ctx_handle_t*, tiledb_query_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*)
Line
Count
Source
624
19.6k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
19.6k
    tiledb::api::ExceptionActionCtx action{ctx};
626
19.6k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
19.6k
  }
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_submit_and_finalize(tiledb_ctx_handle_t*, tiledb_query_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*)
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_submit(tiledb_ctx_handle_t*, tiledb_query_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*)
Line
Count
Source
624
27.0k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
27.0k
    tiledb::api::ExceptionActionCtx action{ctx};
626
27.0k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
27.0k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_submit_async(tiledb_ctx_handle_t*, tiledb_query_t*, void (*)(void*), void*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, void (*)(void*), void*)
Line
Count
Source
624
90
      tiledb_ctx_handle_t* ctx, Args... args) {
625
90
    tiledb::api::ExceptionActionCtx action{ctx};
626
90
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
90
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_has_results(tiledb_ctx_handle_t*, tiledb_query_t*, int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, int*)
Line
Count
Source
624
115
      tiledb_ctx_handle_t* ctx, Args... args) {
625
115
    tiledb::api::ExceptionActionCtx action{ctx};
626
115
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
115
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_status(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_query_status_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_query_status_t*)
Line
Count
Source
624
3.97M
      tiledb_ctx_handle_t* ctx, Args... args) {
625
3.97M
    tiledb::api::ExceptionActionCtx action{ctx};
626
3.97M
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
3.97M
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_type(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_query_type_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_query_type_t*)
Line
Count
Source
624
1.16k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
1.16k
    tiledb::api::ExceptionActionCtx action{ctx};
626
1.16k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
1.16k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_layout(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_layout_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_layout_t*)
Line
Count
Source
624
122
      tiledb_ctx_handle_t* ctx, Args... args) {
625
122
    tiledb::api::ExceptionActionCtx action{ctx};
626
122
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
122
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_array(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_array_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_array_t**)
Line
Count
Source
624
1
      tiledb_ctx_handle_t* ctx, Args... args) {
625
1
    tiledb::api::ExceptionActionCtx action{ctx};
626
1
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
1
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_add_range(tiledb_ctx_handle_t*, tiledb_query_t*, unsigned int, void const*, void const*, void const*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, unsigned int, void const*, void const*, void const*)
Line
Count
Source
624
808
      tiledb_ctx_handle_t* ctx, Args... args) {
625
808
    tiledb::api::ExceptionActionCtx action{ctx};
626
808
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
808
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_add_point_ranges(tiledb_ctx_handle_t*, tiledb_query_t*, unsigned int, void const*, unsigned long long))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, unsigned int, void const*, unsigned long long)
Line
Count
Source
624
4
      tiledb_ctx_handle_t* ctx, Args... args) {
625
4
    tiledb::api::ExceptionActionCtx action{ctx};
626
4
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
4
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_add_range_by_name(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void const*, void const*, void const*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void const*, void const*, void const*)
Line
Count
Source
624
2.97k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2.97k
    tiledb::api::ExceptionActionCtx action{ctx};
626
2.97k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2.97k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_add_range_var(tiledb_ctx_handle_t*, tiledb_query_t*, unsigned int, void const*, unsigned long long, void const*, unsigned long long))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, unsigned int, void const*, unsigned long long, void const*, unsigned long long)
Line
Count
Source
624
230
      tiledb_ctx_handle_t* ctx, Args... args) {
625
230
    tiledb::api::ExceptionActionCtx action{ctx};
626
230
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
230
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_add_range_var_by_name(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void const*, unsigned long long, void const*, unsigned long long))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void const*, unsigned long long, void const*, unsigned long long)
Line
Count
Source
624
141
      tiledb_ctx_handle_t* ctx, Args... args) {
625
141
    tiledb::api::ExceptionActionCtx action{ctx};
626
141
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
141
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_range_num(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int, unsigned long long*)
Line
Count
Source
624
133
      tiledb_ctx_handle_t* ctx, Args... args) {
625
133
    tiledb::api::ExceptionActionCtx action{ctx};
626
133
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
133
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_range_num_from_name(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*)
Line
Count
Source
624
4
      tiledb_ctx_handle_t* ctx, Args... args) {
625
4
    tiledb::api::ExceptionActionCtx action{ctx};
626
4
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
4
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_range(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int, unsigned long long, void const**, void const**, void const**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int, unsigned long long, void const**, void const**, void const**)
Line
Count
Source
624
65
      tiledb_ctx_handle_t* ctx, Args... args) {
625
65
    tiledb::api::ExceptionActionCtx action{ctx};
626
65
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
65
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_range_from_name(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long, void const**, void const**, void const**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long, void const**, void const**, void const**)
Line
Count
Source
624
2
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2
    tiledb::api::ExceptionActionCtx action{ctx};
626
2
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_range_var_size(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int, unsigned long long, unsigned long long*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int, unsigned long long, unsigned long long*, unsigned long long*)
Line
Count
Source
624
172
      tiledb_ctx_handle_t* ctx, Args... args) {
625
172
    tiledb::api::ExceptionActionCtx action{ctx};
626
172
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
172
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_range_var_size_from_name(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long, unsigned long long*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long, unsigned long long*, unsigned long long*)
Line
Count
Source
624
2
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2
    tiledb::api::ExceptionActionCtx action{ctx};
626
2
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_range_var(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int, unsigned long long, void*, void*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int, unsigned long long, void*, void*)
Line
Count
Source
624
172
      tiledb_ctx_handle_t* ctx, Args... args) {
625
172
    tiledb::api::ExceptionActionCtx action{ctx};
626
172
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
172
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_range_var_from_name(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long, void*, void*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long, void*, void*)
Line
Count
Source
624
2
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2
    tiledb::api::ExceptionActionCtx action{ctx};
626
2
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_est_result_size(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*)
Line
Count
Source
624
221
      tiledb_ctx_handle_t* ctx, Args... args) {
625
221
    tiledb::api::ExceptionActionCtx action{ctx};
626
221
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
221
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_est_result_size_var(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*, unsigned long long*)
Line
Count
Source
624
101
      tiledb_ctx_handle_t* ctx, Args... args) {
625
101
    tiledb::api::ExceptionActionCtx action{ctx};
626
101
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
101
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_est_result_size_nullable(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*, unsigned long long*)
Line
Count
Source
624
6
      tiledb_ctx_handle_t* ctx, Args... args) {
625
6
    tiledb::api::ExceptionActionCtx action{ctx};
626
6
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
6
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_est_result_size_var_nullable(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*, unsigned long long*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t const*, char const*, unsigned long long*, unsigned long long*, unsigned long long*)
Line
Count
Source
624
3
      tiledb_ctx_handle_t* ctx, Args... args) {
625
3
    tiledb::api::ExceptionActionCtx action{ctx};
626
3
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
3
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_fragment_num(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned int*)
Line
Count
Source
624
10
      tiledb_ctx_handle_t* ctx, Args... args) {
625
10
    tiledb::api::ExceptionActionCtx action{ctx};
626
10
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
10
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_fragment_uri(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned long long, char const**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned long long, char const**)
Line
Count
Source
624
232
      tiledb_ctx_handle_t* ctx, Args... args) {
625
232
    tiledb::api::ExceptionActionCtx action{ctx};
626
232
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
232
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_fragment_timestamp_range(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned long long, unsigned long long*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned long long, unsigned long long*, unsigned long long*)
Line
Count
Source
624
14
      tiledb_ctx_handle_t* ctx, Args... args) {
625
14
    tiledb::api::ExceptionActionCtx action{ctx};
626
14
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
14
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_subarray_t(tiledb_ctx_handle_t*, tiledb_query_t const*, tiledb_subarray_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t const*, tiledb_subarray_t**)
Line
Count
Source
624
9
      tiledb_ctx_handle_t* ctx, Args... args) {
625
9
    tiledb::api::ExceptionActionCtx action{ctx};
626
9
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
9
  }
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_relevant_fragment_num(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t const*, unsigned long long*)
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_subarray_alloc(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_subarray_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_subarray_t**)
Line
Count
Source
624
4.22k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
4.22k
    tiledb::api::ExceptionActionCtx action{ctx};
626
4.22k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
4.22k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_subarray_set_config(tiledb_ctx_handle_t*, tiledb_subarray_t*, tiledb_config_handle_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_subarray_t*, tiledb_config_handle_t*)
Line
Count
Source
624
9
      tiledb_ctx_handle_t* ctx, Args... args) {
625
9
    tiledb::api::ExceptionActionCtx action{ctx};
626
9
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
9
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_subarray_set_coalesce_ranges(tiledb_ctx_handle_t*, tiledb_subarray_t*, int))>::function_with_context(tiledb_ctx_handle_t*, tiledb_subarray_t*, int)
Line
Count
Source
624
4.21k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
4.21k
    tiledb::api::ExceptionActionCtx action{ctx};
626
4.21k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
4.21k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_subarray_set_subarray(tiledb_ctx_handle_t*, tiledb_subarray_t*, void const*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_subarray_t*, void const*)
Line
Count
Source
624
16
      tiledb_ctx_handle_t* ctx, Args... args) {
625
16
    tiledb::api::ExceptionActionCtx action{ctx};
626
16
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
16
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_subarray_add_range(tiledb_ctx_handle_t*, tiledb_subarray_t*, unsigned int, void const*, void const*, void const*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_subarray_t*, unsigned int, void const*, void const*, void const*)
Line
Count
Source
624
1.01k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
1.01k
    tiledb::api::ExceptionActionCtx action{ctx};
626
1.01k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
1.01k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_subarray_add_point_ranges(tiledb_ctx_handle_t*, tiledb_subarray_t*, unsigned int, void const*, unsigned long long))>::function_with_context(tiledb_ctx_handle_t*, tiledb_subarray_t*, unsigned int, void const*, unsigned long long)
Line
Count
Source
624
4
      tiledb_ctx_handle_t* ctx, Args... args) {
625
4
    tiledb::api::ExceptionActionCtx action{ctx};
626
4
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
4
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_subarray_add_range_by_name(tiledb_ctx_handle_t*, tiledb_subarray_t*, char const*, void const*, void const*, void const*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_subarray_t*, char const*, void const*, void const*, void const*)
Line
Count
Source
624
2.97k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2.97k
    tiledb::api::ExceptionActionCtx action{ctx};
626
2.97k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2.97k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_subarray_add_range_var(tiledb_ctx_handle_t*, tiledb_subarray_t*, unsigned int, void const*, unsigned long long, void const*, unsigned long long))>::function_with_context(tiledb_ctx_handle_t*, tiledb_subarray_t*, unsigned int, void const*, unsigned long long, void const*, unsigned long long)
Line
Count
Source
624
230
      tiledb_ctx_handle_t* ctx, Args... args) {
625
230
    tiledb::api::ExceptionActionCtx action{ctx};
626
230
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
230
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_subarray_add_range_var_by_name(tiledb_ctx_handle_t*, tiledb_subarray_t*, char const*, void const*, unsigned long long, void const*, unsigned long long))>::function_with_context(tiledb_ctx_handle_t*, tiledb_subarray_t*, char const*, void const*, unsigned long long, void const*, unsigned long long)
Line
Count
Source
624
141
      tiledb_ctx_handle_t* ctx, Args... args) {
625
141
    tiledb::api::ExceptionActionCtx action{ctx};
626
141
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
141
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_subarray_get_range_num(tiledb_ctx_handle_t*, tiledb_subarray_t const*, unsigned int, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_subarray_t const*, unsigned int, unsigned long long*)
Line
Count
Source
624
139
      tiledb_ctx_handle_t* ctx, Args... args) {
625
139
    tiledb::api::ExceptionActionCtx action{ctx};
626
139
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
139
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_subarray_get_range_num_from_name(tiledb_ctx_handle_t*, tiledb_subarray_t const*, char const*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_subarray_t const*, char const*, unsigned long long*)
Line
Count
Source
624
4
      tiledb_ctx_handle_t* ctx, Args... args) {
625
4
    tiledb::api::ExceptionActionCtx action{ctx};
626
4
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
4
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_subarray_get_range(tiledb_ctx_handle_t*, tiledb_subarray_t const*, unsigned int, unsigned long long, void const**, void const**, void const**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_subarray_t const*, unsigned int, unsigned long long, void const**, void const**, void const**)
Line
Count
Source
624
70
      tiledb_ctx_handle_t* ctx, Args... args) {
625
70
    tiledb::api::ExceptionActionCtx action{ctx};
626
70
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
70
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_subarray_get_range_var_size(tiledb_ctx_handle_t*, tiledb_subarray_t const*, unsigned int, unsigned long long, unsigned long long*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_subarray_t const*, unsigned int, unsigned long long, unsigned long long*, unsigned long long*)
Line
Count
Source
624
172
      tiledb_ctx_handle_t* ctx, Args... args) {
625
172
    tiledb::api::ExceptionActionCtx action{ctx};
626
172
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
172
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_subarray_get_range_from_name(tiledb_ctx_handle_t*, tiledb_subarray_t const*, char const*, unsigned long long, void const**, void const**, void const**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_subarray_t const*, char const*, unsigned long long, void const**, void const**, void const**)
Line
Count
Source
624
2
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2
    tiledb::api::ExceptionActionCtx action{ctx};
626
2
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_subarray_get_range_var_size_from_name(tiledb_ctx_handle_t*, tiledb_subarray_t const*, char const*, unsigned long long, unsigned long long*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_subarray_t const*, char const*, unsigned long long, unsigned long long*, unsigned long long*)
Line
Count
Source
624
2
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2
    tiledb::api::ExceptionActionCtx action{ctx};
626
2
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_subarray_get_range_var(tiledb_ctx_handle_t*, tiledb_subarray_t const*, unsigned int, unsigned long long, void*, void*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_subarray_t const*, unsigned int, unsigned long long, void*, void*)
Line
Count
Source
624
172
      tiledb_ctx_handle_t* ctx, Args... args) {
625
172
    tiledb::api::ExceptionActionCtx action{ctx};
626
172
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
172
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_subarray_get_range_var_from_name(tiledb_ctx_handle_t*, tiledb_subarray_t const*, char const*, unsigned long long, void*, void*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_subarray_t const*, char const*, unsigned long long, void*, void*)
Line
Count
Source
624
2
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2
    tiledb::api::ExceptionActionCtx action{ctx};
626
2
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_condition_alloc(tiledb_ctx_handle_t*, tiledb_query_condition_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_condition_t**)
Line
Count
Source
624
7.00k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
7.00k
    tiledb::api::ExceptionActionCtx action{ctx};
626
7.00k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
7.00k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_condition_init(tiledb_ctx_handle_t*, tiledb_query_condition_t*, char const*, void const*, unsigned long long, tiledb_query_condition_op_t))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_condition_t*, char const*, void const*, unsigned long long, tiledb_query_condition_op_t)
Line
Count
Source
624
7.00k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
7.00k
    tiledb::api::ExceptionActionCtx action{ctx};
626
7.00k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
7.00k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_condition_combine(tiledb_ctx_handle_t*, tiledb_query_condition_t const*, tiledb_query_condition_t const*, tiledb_query_condition_combination_op_t, tiledb_query_condition_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_condition_t const*, tiledb_query_condition_t const*, tiledb_query_condition_combination_op_t, tiledb_query_condition_t**)
Line
Count
Source
624
1.82k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
1.82k
    tiledb::api::ExceptionActionCtx action{ctx};
626
1.82k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
1.82k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_add_update_value(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void const*, unsigned long long))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, char const*, void const*, unsigned long long)
Line
Count
Source
624
15
      tiledb_ctx_handle_t* ctx, Args... args) {
625
15
    tiledb::api::ExceptionActionCtx action{ctx};
626
15
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
15
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_alloc(tiledb_ctx_handle_t*, char const*, tiledb_array_t**))>::function_with_context(tiledb_ctx_handle_t*, char const*, tiledb_array_t**)
Line
Count
Source
624
28.6k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
28.6k
    tiledb::api::ExceptionActionCtx action{ctx};
626
28.6k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
28.6k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_set_open_timestamp_start(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long)
Line
Count
Source
624
161
      tiledb_ctx_handle_t* ctx, Args... args) {
625
161
    tiledb::api::ExceptionActionCtx action{ctx};
626
161
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
161
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_set_open_timestamp_end(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long)
Line
Count
Source
624
529
      tiledb_ctx_handle_t* ctx, Args... args) {
625
529
    tiledb::api::ExceptionActionCtx action{ctx};
626
529
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
529
  }
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_get_open_timestamp_start(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long*)
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_get_open_timestamp_end(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long*)
Line
Count
Source
624
28
      tiledb_ctx_handle_t* ctx, Args... args) {
625
28
    tiledb::api::ExceptionActionCtx action{ctx};
626
28
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
28
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_delete_array(tiledb_ctx_handle_t*, tiledb_array_t*, char const*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, char const*)
Line
Count
Source
624
4
      tiledb_ctx_handle_t* ctx, Args... args) {
625
4
    tiledb::api::ExceptionActionCtx action{ctx};
626
4
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
4
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_delete_fragments(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, unsigned long long, unsigned long long))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, unsigned long long, unsigned long long)
Line
Count
Source
624
5
      tiledb_ctx_handle_t* ctx, Args... args) {
625
5
    tiledb::api::ExceptionActionCtx action{ctx};
626
5
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
5
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_open(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t)
Line
Count
Source
624
24.5k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
24.5k
    tiledb::api::ExceptionActionCtx action{ctx};
626
24.5k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
24.5k
  }
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_open_at(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t, unsigned long long))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t, unsigned long long)
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_open_with_key(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t, tiledb_encryption_type_t, void const*, unsigned int))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t, tiledb_encryption_type_t, void const*, unsigned int)
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_open_at_with_key(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t, tiledb_encryption_type_t, void const*, unsigned int, unsigned long long))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t, tiledb_encryption_type_t, void const*, unsigned int, unsigned long long)
Line
Count
Source
624
4.19k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
4.19k
    tiledb::api::ExceptionActionCtx action{ctx};
626
4.19k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
4.19k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_is_open(tiledb_ctx_handle_t*, tiledb_array_t*, int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, int*)
Line
Count
Source
624
15.0k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
15.0k
    tiledb::api::ExceptionActionCtx action{ctx};
626
15.0k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
15.0k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_reopen(tiledb_ctx_handle_t*, tiledb_array_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*)
Line
Count
Source
624
168
      tiledb_ctx_handle_t* ctx, Args... args) {
625
168
    tiledb::api::ExceptionActionCtx action{ctx};
626
168
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
168
  }
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_reopen_at(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long)
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_get_timestamp(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long*)
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_set_config(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_config_handle_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_config_handle_t*)
Line
Count
Source
624
5.46k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
5.46k
    tiledb::api::ExceptionActionCtx action{ctx};
626
5.46k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
5.46k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_get_config(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_config_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_config_handle_t**)
Line
Count
Source
624
5
      tiledb_ctx_handle_t* ctx, Args... args) {
625
5
    tiledb::api::ExceptionActionCtx action{ctx};
626
5
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
5
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_close(tiledb_ctx_handle_t*, tiledb_array_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*)
Line
Count
Source
624
28.7k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
28.7k
    tiledb::api::ExceptionActionCtx action{ctx};
626
28.7k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
28.7k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_get_schema(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_array_schema_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_array_schema_t**)
Line
Count
Source
624
33.9k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
33.9k
    tiledb::api::ExceptionActionCtx action{ctx};
626
33.9k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
33.9k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_get_query_type(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_query_type_t*)
Line
Count
Source
624
5.83k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
5.83k
    tiledb::api::ExceptionActionCtx action{ctx};
626
5.83k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
5.83k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_create(tiledb_ctx_handle_t*, char const*, tiledb_array_schema_t const*))>::function_with_context(tiledb_ctx_handle_t*, char const*, tiledb_array_schema_t const*)
Line
Count
Source
624
9.38k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
9.38k
    tiledb::api::ExceptionActionCtx action{ctx};
626
9.38k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
9.38k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_create_with_key(tiledb_ctx_handle_t*, char const*, tiledb_array_schema_t const*, tiledb_encryption_type_t, void const*, unsigned int))>::function_with_context(tiledb_ctx_handle_t*, char const*, tiledb_array_schema_t const*, tiledb_encryption_type_t, void const*, unsigned int)
Line
Count
Source
624
2
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2
    tiledb::api::ExceptionActionCtx action{ctx};
626
2
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_consolidate(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*))>::function_with_context(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)
Line
Count
Source
624
968
      tiledb_ctx_handle_t* ctx, Args... args) {
625
968
    tiledb::api::ExceptionActionCtx action{ctx};
626
968
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
968
  }
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_consolidate_with_key(tiledb_ctx_handle_t*, char const*, tiledb_encryption_type_t, void const*, unsigned int, tiledb_config_handle_t*))>::function_with_context(tiledb_ctx_handle_t*, char const*, tiledb_encryption_type_t, void const*, unsigned int, tiledb_config_handle_t*)
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_consolidate_fragments(tiledb_ctx_handle_t*, char const*, char const**, unsigned long long, tiledb_config_handle_t*))>::function_with_context(tiledb_ctx_handle_t*, char const*, char const**, unsigned long long, tiledb_config_handle_t*)
Line
Count
Source
624
3
      tiledb_ctx_handle_t* ctx, Args... args) {
625
3
    tiledb::api::ExceptionActionCtx action{ctx};
626
3
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
3
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_vacuum(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*))>::function_with_context(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)
Line
Count
Source
624
514
      tiledb_ctx_handle_t* ctx, Args... args) {
625
514
    tiledb::api::ExceptionActionCtx action{ctx};
626
514
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
514
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_get_non_empty_domain(tiledb_ctx_handle_t*, tiledb_array_t*, void*, int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, void*, int*)
Line
Count
Source
624
13
      tiledb_ctx_handle_t* ctx, Args... args) {
625
13
    tiledb::api::ExceptionActionCtx action{ctx};
626
13
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
13
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_get_non_empty_domain_from_index(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned int, void*, int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned int, void*, int*)
Line
Count
Source
624
195
      tiledb_ctx_handle_t* ctx, Args... args) {
625
195
    tiledb::api::ExceptionActionCtx action{ctx};
626
195
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
195
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_get_non_empty_domain_from_name(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, void*, int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, void*, int*)
Line
Count
Source
624
76
      tiledb_ctx_handle_t* ctx, Args... args) {
625
76
    tiledb::api::ExceptionActionCtx action{ctx};
626
76
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
76
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_get_non_empty_domain_var_size_from_index(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned int, unsigned long long*, unsigned long long*, int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned int, unsigned long long*, unsigned long long*, int*)
Line
Count
Source
624
166
      tiledb_ctx_handle_t* ctx, Args... args) {
625
166
    tiledb::api::ExceptionActionCtx action{ctx};
626
166
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
166
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_get_non_empty_domain_var_size_from_name(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, unsigned long long*, unsigned long long*, int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, unsigned long long*, unsigned long long*, int*)
Line
Count
Source
624
72
      tiledb_ctx_handle_t* ctx, Args... args) {
625
72
    tiledb::api::ExceptionActionCtx action{ctx};
626
72
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
72
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_get_non_empty_domain_var_from_index(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned int, void*, void*, int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned int, void*, void*, int*)
Line
Count
Source
624
152
      tiledb_ctx_handle_t* ctx, Args... args) {
625
152
    tiledb::api::ExceptionActionCtx action{ctx};
626
152
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
152
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_get_non_empty_domain_var_from_name(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, void*, void*, int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, void*, void*, int*)
Line
Count
Source
624
58
      tiledb_ctx_handle_t* ctx, Args... args) {
625
58
    tiledb::api::ExceptionActionCtx action{ctx};
626
58
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
58
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_get_uri(tiledb_ctx_handle_t*, tiledb_array_t*, char const**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, char const**)
Line
Count
Source
624
114
      tiledb_ctx_handle_t* ctx, Args... args) {
625
114
    tiledb::api::ExceptionActionCtx action{ctx};
626
114
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
114
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_encryption_type(tiledb_ctx_handle_t*, char const*, tiledb_encryption_type_t*))>::function_with_context(tiledb_ctx_handle_t*, char const*, tiledb_encryption_type_t*)
Line
Count
Source
624
11
      tiledb_ctx_handle_t* ctx, Args... args) {
625
11
    tiledb::api::ExceptionActionCtx action{ctx};
626
11
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
11
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_put_metadata(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, tiledb_datatype_t, unsigned int, void const*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, tiledb_datatype_t, unsigned int, void const*)
Line
Count
Source
624
96
      tiledb_ctx_handle_t* ctx, Args... args) {
625
96
    tiledb::api::ExceptionActionCtx action{ctx};
626
96
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
96
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_delete_metadata(tiledb_ctx_handle_t*, tiledb_array_t*, char const*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, char const*)
Line
Count
Source
624
15
      tiledb_ctx_handle_t* ctx, Args... args) {
625
15
    tiledb::api::ExceptionActionCtx action{ctx};
626
15
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
15
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_get_metadata(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, tiledb_datatype_t*, unsigned int*, void const**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, tiledb_datatype_t*, unsigned int*, void const**)
Line
Count
Source
624
64
      tiledb_ctx_handle_t* ctx, Args... args) {
625
64
    tiledb::api::ExceptionActionCtx action{ctx};
626
64
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
64
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_get_metadata_num(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long*)
Line
Count
Source
624
23
      tiledb_ctx_handle_t* ctx, Args... args) {
625
23
    tiledb::api::ExceptionActionCtx action{ctx};
626
23
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
23
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_get_metadata_from_index(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long, char const**, unsigned int*, tiledb_datatype_t*, unsigned int*, void const**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long, char const**, unsigned int*, tiledb_datatype_t*, unsigned int*, void const**)
Line
Count
Source
624
13
      tiledb_ctx_handle_t* ctx, Args... args) {
625
13
    tiledb::api::ExceptionActionCtx action{ctx};
626
13
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
13
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_has_metadata_key(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, tiledb_datatype_t*, int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, char const*, tiledb_datatype_t*, int*)
Line
Count
Source
624
6
      tiledb_ctx_handle_t* ctx, Args... args) {
625
6
    tiledb::api::ExceptionActionCtx action{ctx};
626
6
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
6
  }
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_consolidate_metadata(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*))>::function_with_context(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_consolidate_metadata_with_key(tiledb_ctx_handle_t*, char const*, tiledb_encryption_type_t, void const*, unsigned int, tiledb_config_handle_t*))>::function_with_context(tiledb_ctx_handle_t*, char const*, tiledb_encryption_type_t, void const*, unsigned int, tiledb_config_handle_t*)
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_evolve(tiledb_ctx_handle_t*, char const*, tiledb_array_schema_evolution_t*))>::function_with_context(tiledb_ctx_handle_t*, char const*, tiledb_array_schema_evolution_t*)
Line
Count
Source
624
13
      tiledb_ctx_handle_t* ctx, Args... args) {
625
13
    tiledb::api::ExceptionActionCtx action{ctx};
626
13
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
13
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_array_upgrade_version(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*))>::function_with_context(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)
Line
Count
Source
624
7
      tiledb_ctx_handle_t* ctx, Args... args) {
625
7
    tiledb::api::ExceptionActionCtx action{ctx};
626
7
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
7
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_object_type(tiledb_ctx_handle_t*, char const*, tiledb_object_t*))>::function_with_context(tiledb_ctx_handle_t*, char const*, tiledb_object_t*)
Line
Count
Source
624
473
      tiledb_ctx_handle_t* ctx, Args... args) {
625
473
    tiledb::api::ExceptionActionCtx action{ctx};
626
473
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
473
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_object_remove(tiledb_ctx_handle_t*, char const*))>::function_with_context(tiledb_ctx_handle_t*, char const*)
Line
Count
Source
624
250
      tiledb_ctx_handle_t* ctx, Args... args) {
625
250
    tiledb::api::ExceptionActionCtx action{ctx};
626
250
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
250
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_object_move(tiledb_ctx_handle_t*, char const*, char const*))>::function_with_context(tiledb_ctx_handle_t*, char const*, char const*)
Line
Count
Source
624
3
      tiledb_ctx_handle_t* ctx, Args... args) {
625
3
    tiledb::api::ExceptionActionCtx action{ctx};
626
3
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
3
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_object_walk(tiledb_ctx_handle_t*, char const*, tiledb_walk_order_t, int (*)(char const*, tiledb_object_t, void*), void*))>::function_with_context(tiledb_ctx_handle_t*, char const*, tiledb_walk_order_t, int (*)(char const*, tiledb_object_t, void*), void*)
Line
Count
Source
624
2
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2
    tiledb::api::ExceptionActionCtx action{ctx};
626
2
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_object_ls(tiledb_ctx_handle_t*, char const*, int (*)(char const*, tiledb_object_t, void*), void*))>::function_with_context(tiledb_ctx_handle_t*, char const*, int (*)(char const*, tiledb_object_t, void*), void*)
Line
Count
Source
624
1
      tiledb_ctx_handle_t* ctx, Args... args) {
625
1
    tiledb::api::ExceptionActionCtx action{ctx};
626
1
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
1
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_vfs_alloc(tiledb_ctx_handle_t*, tiledb_config_handle_t*, tiledb_vfs_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_config_handle_t*, tiledb_vfs_t**)
Line
Count
Source
624
5.32k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
5.32k
    tiledb::api::ExceptionActionCtx action{ctx};
626
5.32k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
5.32k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_vfs_get_config(tiledb_ctx_handle_t*, tiledb_vfs_t*, tiledb_config_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_vfs_t*, tiledb_config_handle_t**)
Line
Count
Source
624
2
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2
    tiledb::api::ExceptionActionCtx action{ctx};
626
2
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_vfs_create_bucket(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)
Line
Count
Source
624
1
      tiledb_ctx_handle_t* ctx, Args... args) {
625
1
    tiledb::api::ExceptionActionCtx action{ctx};
626
1
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
1
  }
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_vfs_remove_bucket(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_vfs_empty_bucket(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_vfs_is_empty_bucket(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int*)
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_vfs_is_bucket(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int*)
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_vfs_create_dir(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)
Line
Count
Source
624
6.26k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
6.26k
    tiledb::api::ExceptionActionCtx action{ctx};
626
6.26k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
6.26k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_vfs_is_dir(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int*)
Line
Count
Source
624
13.2k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
13.2k
    tiledb::api::ExceptionActionCtx action{ctx};
626
13.2k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
13.2k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_vfs_remove_dir(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)
Line
Count
Source
624
9.25k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
9.25k
    tiledb::api::ExceptionActionCtx action{ctx};
626
9.25k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
9.25k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_vfs_is_file(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int*)
Line
Count
Source
624
185
      tiledb_ctx_handle_t* ctx, Args... args) {
625
185
    tiledb::api::ExceptionActionCtx action{ctx};
626
185
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
185
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_vfs_remove_file(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)
Line
Count
Source
624
82
      tiledb_ctx_handle_t* ctx, Args... args) {
625
82
    tiledb::api::ExceptionActionCtx action{ctx};
626
82
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
82
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_vfs_dir_size(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, unsigned long long*)
Line
Count
Source
624
9
      tiledb_ctx_handle_t* ctx, Args... args) {
625
9
    tiledb::api::ExceptionActionCtx action{ctx};
626
9
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
9
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_vfs_file_size(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, unsigned long long*)
Line
Count
Source
624
94
      tiledb_ctx_handle_t* ctx, Args... args) {
625
94
    tiledb::api::ExceptionActionCtx action{ctx};
626
94
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
94
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_vfs_move_file(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, char const*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, char const*)
Line
Count
Source
624
4
      tiledb_ctx_handle_t* ctx, Args... args) {
625
4
    tiledb::api::ExceptionActionCtx action{ctx};
626
4
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
4
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_vfs_move_dir(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, char const*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, char const*)
Line
Count
Source
624
8
      tiledb_ctx_handle_t* ctx, Args... args) {
625
8
    tiledb::api::ExceptionActionCtx action{ctx};
626
8
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
8
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_vfs_copy_file(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, char const*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, char const*)
Line
Count
Source
624
3
      tiledb_ctx_handle_t* ctx, Args... args) {
625
3
    tiledb::api::ExceptionActionCtx action{ctx};
626
3
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
3
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_vfs_copy_dir(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, char const*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, char const*)
Line
Count
Source
624
9
      tiledb_ctx_handle_t* ctx, Args... args) {
625
9
    tiledb::api::ExceptionActionCtx action{ctx};
626
9
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
9
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_vfs_open(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, tiledb_vfs_mode_t, tiledb_vfs_fh_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, tiledb_vfs_mode_t, tiledb_vfs_fh_t**)
Line
Count
Source
624
91
      tiledb_ctx_handle_t* ctx, Args... args) {
625
91
    tiledb::api::ExceptionActionCtx action{ctx};
626
91
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
91
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_vfs_close(tiledb_ctx_handle_t*, tiledb_vfs_fh_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_vfs_fh_t*)
Line
Count
Source
624
85
      tiledb_ctx_handle_t* ctx, Args... args) {
625
85
    tiledb::api::ExceptionActionCtx action{ctx};
626
85
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
85
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_vfs_read(tiledb_ctx_handle_t*, tiledb_vfs_fh_t*, unsigned long long, void*, unsigned long long))>::function_with_context(tiledb_ctx_handle_t*, tiledb_vfs_fh_t*, unsigned long long, void*, unsigned long long)
Line
Count
Source
624
48
      tiledb_ctx_handle_t* ctx, Args... args) {
625
48
    tiledb::api::ExceptionActionCtx action{ctx};
626
48
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
48
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_vfs_write(tiledb_ctx_handle_t*, tiledb_vfs_fh_t*, void const*, unsigned long long))>::function_with_context(tiledb_ctx_handle_t*, tiledb_vfs_fh_t*, void const*, unsigned long long)
Line
Count
Source
624
42
      tiledb_ctx_handle_t* ctx, Args... args) {
625
42
    tiledb::api::ExceptionActionCtx action{ctx};
626
42
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
42
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_vfs_sync(tiledb_ctx_handle_t*, tiledb_vfs_fh_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_vfs_fh_t*)
Line
Count
Source
624
6
      tiledb_ctx_handle_t* ctx, Args... args) {
625
6
    tiledb::api::ExceptionActionCtx action{ctx};
626
6
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
6
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_vfs_ls(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int (*)(char const*, void*), void*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*, int (*)(char const*, void*), void*)
Line
Count
Source
624
498
      tiledb_ctx_handle_t* ctx, Args... args) {
625
498
    tiledb::api::ExceptionActionCtx action{ctx};
626
498
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
498
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_vfs_fh_is_closed(tiledb_ctx_handle_t*, tiledb_vfs_fh_t*, int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_vfs_fh_t*, int*)
Line
Count
Source
624
16
      tiledb_ctx_handle_t* ctx, Args... args) {
625
16
    tiledb::api::ExceptionActionCtx action{ctx};
626
16
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
16
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_vfs_touch(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_vfs_t*, char const*)
Line
Count
Source
624
1.06k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
1.06k
    tiledb::api::ExceptionActionCtx action{ctx};
626
1.06k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
1.06k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_uri_to_path(tiledb_ctx_handle_t*, char const*, char*, unsigned int*))>::function_with_context(tiledb_ctx_handle_t*, char const*, char*, unsigned int*)
Line
Count
Source
624
8
      tiledb_ctx_handle_t* ctx, Args... args) {
625
8
    tiledb::api::ExceptionActionCtx action{ctx};
626
8
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
8
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_serialize_array(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)
Line
Count
Source
624
2
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2
    tiledb::api::ExceptionActionCtx action{ctx};
626
2
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_deserialize_array(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_array_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_array_t**)
Line
Count
Source
624
2
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2
    tiledb::api::ExceptionActionCtx action{ctx};
626
2
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_serialize_array_schema(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)
Line
Count
Source
624
36
      tiledb_ctx_handle_t* ctx, Args... args) {
625
36
    tiledb::api::ExceptionActionCtx action{ctx};
626
36
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
36
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_deserialize_array_schema(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_array_schema_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_array_schema_t**)
Line
Count
Source
624
37
      tiledb_ctx_handle_t* ctx, Args... args) {
625
37
    tiledb::api::ExceptionActionCtx action{ctx};
626
37
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
37
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_serialize_array_open(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)
Line
Count
Source
624
1
      tiledb_ctx_handle_t* ctx, Args... args) {
625
1
    tiledb::api::ExceptionActionCtx action{ctx};
626
1
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
1
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_deserialize_array_open(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_array_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_array_t**)
Line
Count
Source
624
1
      tiledb_ctx_handle_t* ctx, Args... args) {
625
1
    tiledb::api::ExceptionActionCtx action{ctx};
626
1
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
1
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_serialize_array_schema_evolution(tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_schema_evolution_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)
Line
Count
Source
624
3
      tiledb_ctx_handle_t* ctx, Args... args) {
625
3
    tiledb::api::ExceptionActionCtx action{ctx};
626
3
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
3
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_deserialize_array_schema_evolution(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_array_schema_evolution_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_array_schema_evolution_t**)
Line
Count
Source
624
3
      tiledb_ctx_handle_t* ctx, Args... args) {
625
3
    tiledb::api::ExceptionActionCtx action{ctx};
626
3
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
3
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_serialize_query(tiledb_ctx_handle_t*, tiledb_query_t const*, tiledb_serialization_type_t, int, tiledb_buffer_list_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t const*, tiledb_serialization_type_t, int, tiledb_buffer_list_t**)
Line
Count
Source
624
2.42k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2.42k
    tiledb::api::ExceptionActionCtx action{ctx};
626
2.42k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2.42k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_deserialize_query(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_query_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_query_t*)
Line
Count
Source
624
2.42k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2.42k
    tiledb::api::ExceptionActionCtx action{ctx};
626
2.42k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2.42k
  }
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_serialize_array_nonempty_domain(tiledb_ctx_handle_t*, tiledb_array_t const*, void const*, int, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t const*, void const*, int, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_deserialize_array_nonempty_domain(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, void*, int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, void*, int*)
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_serialize_array_non_empty_domain_all_dimensions(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)
Line
Count
Source
624
36
      tiledb_ctx_handle_t* ctx, Args... args) {
625
36
    tiledb::api::ExceptionActionCtx action{ctx};
626
36
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
36
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_deserialize_array_non_empty_domain_all_dimensions(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int)
Line
Count
Source
624
36
      tiledb_ctx_handle_t* ctx, Args... args) {
625
36
    tiledb::api::ExceptionActionCtx action{ctx};
626
36
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
36
  }
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_serialize_array_max_buffer_sizes(tiledb_ctx_handle_t*, tiledb_array_t const*, void const*, tiledb_serialization_type_t, tiledb_buffer_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t const*, void const*, tiledb_serialization_type_t, tiledb_buffer_handle_t**)
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_serialize_array_metadata(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_serialization_type_t, tiledb_buffer_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t const*, tiledb_serialization_type_t, tiledb_buffer_handle_t**)
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_deserialize_array_metadata(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_serialization_type_t, tiledb_buffer_handle_t const*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, tiledb_serialization_type_t, tiledb_buffer_handle_t const*)
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_serialize_query_est_result_sizes(tiledb_ctx_handle_t*, tiledb_query_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)
Line
Count
Source
624
32
      tiledb_ctx_handle_t* ctx, Args... args) {
625
32
    tiledb::api::ExceptionActionCtx action{ctx};
626
32
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
32
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_deserialize_query_est_result_sizes(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t const*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t const*)
Line
Count
Source
624
32
      tiledb_ctx_handle_t* ctx, Args... args) {
625
32
    tiledb::api::ExceptionActionCtx action{ctx};
626
32
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
32
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_serialize_config(tiledb_ctx_handle_t*, tiledb_config_handle_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_config_handle_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)
Line
Count
Source
624
2
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2
    tiledb::api::ExceptionActionCtx action{ctx};
626
2
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2
  }
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_serialize_fragment_info_request(tiledb_ctx_handle_t*, tiledb_fragment_info_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_deserialize_fragment_info_request(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_fragment_info_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, int, tiledb_fragment_info_t*)
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_serialize_fragment_info(tiledb_ctx_handle_t*, tiledb_fragment_info_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t const*, tiledb_serialization_type_t, int, tiledb_buffer_handle_t**)
Line
Count
Source
624
38
      tiledb_ctx_handle_t* ctx, Args... args) {
625
38
    tiledb::api::ExceptionActionCtx action{ctx};
626
38
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
38
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_deserialize_fragment_info(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, char const*, int, tiledb_fragment_info_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_buffer_handle_t const*, tiledb_serialization_type_t, char const*, int, tiledb_fragment_info_t*)
Line
Count
Source
624
38
      tiledb_ctx_handle_t* ctx, Args... args) {
625
38
    tiledb::api::ExceptionActionCtx action{ctx};
626
38
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
38
  }
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::impl::tiledb_query_submit_async_func(tiledb_ctx_handle_t*, tiledb_query_t*, void*, void*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, void*, void*)
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_alloc(tiledb_ctx_handle_t*, char const*, tiledb_fragment_info_t**))>::function_with_context(tiledb_ctx_handle_t*, char const*, tiledb_fragment_info_t**)
Line
Count
Source
624
111
      tiledb_ctx_handle_t* ctx, Args... args) {
625
111
    tiledb::api::ExceptionActionCtx action{ctx};
626
111
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
111
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_set_config(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, tiledb_config_handle_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, tiledb_config_handle_t*)
Line
Count
Source
624
11
      tiledb_ctx_handle_t* ctx, Args... args) {
625
11
    tiledb::api::ExceptionActionCtx action{ctx};
626
11
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
11
  }
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_config(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, tiledb_config_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, tiledb_config_handle_t**)
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_load(tiledb_ctx_handle_t*, tiledb_fragment_info_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*)
Line
Count
Source
624
101
      tiledb_ctx_handle_t* ctx, Args... args) {
625
101
    tiledb::api::ExceptionActionCtx action{ctx};
626
101
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
101
  }
Unexecuted instantiation: tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_load_with_key(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, tiledb_encryption_type_t, void const*, unsigned int))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, tiledb_encryption_type_t, void const*, unsigned int)
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_fragment_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const**)
Line
Count
Source
624
6
      tiledb_ctx_handle_t* ctx, Args... args) {
625
6
    tiledb::api::ExceptionActionCtx action{ctx};
626
6
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
6
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_fragment_num(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int*)
Line
Count
Source
624
24
      tiledb_ctx_handle_t* ctx, Args... args) {
625
24
    tiledb::api::ExceptionActionCtx action{ctx};
626
24
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
24
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_fragment_uri(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const**)
Line
Count
Source
624
28
      tiledb_ctx_handle_t* ctx, Args... args) {
625
28
    tiledb::api::ExceptionActionCtx action{ctx};
626
28
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
28
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_fragment_size(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned long long*)
Line
Count
Source
624
6
      tiledb_ctx_handle_t* ctx, Args... args) {
625
6
    tiledb::api::ExceptionActionCtx action{ctx};
626
6
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
6
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_dense(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, int*)
Line
Count
Source
624
12
      tiledb_ctx_handle_t* ctx, Args... args) {
625
12
    tiledb::api::ExceptionActionCtx action{ctx};
626
12
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
12
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_sparse(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, int*)
Line
Count
Source
624
12
      tiledb_ctx_handle_t* ctx, Args... args) {
625
12
    tiledb::api::ExceptionActionCtx action{ctx};
626
12
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
12
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_timestamp_range(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned long long*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned long long*, unsigned long long*)
Line
Count
Source
624
6
      tiledb_ctx_handle_t* ctx, Args... args) {
625
6
    tiledb::api::ExceptionActionCtx action{ctx};
626
6
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
6
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_non_empty_domain_from_index(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, void*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, void*)
Line
Count
Source
624
96
      tiledb_ctx_handle_t* ctx, Args... args) {
625
96
    tiledb::api::ExceptionActionCtx action{ctx};
626
96
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
96
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_non_empty_domain_from_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const*, void*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const*, void*)
Line
Count
Source
624
12
      tiledb_ctx_handle_t* ctx, Args... args) {
625
12
    tiledb::api::ExceptionActionCtx action{ctx};
626
12
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
12
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_non_empty_domain_var_size_from_index(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, unsigned long long*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, unsigned long long*, unsigned long long*)
Line
Count
Source
624
10
      tiledb_ctx_handle_t* ctx, Args... args) {
625
10
    tiledb::api::ExceptionActionCtx action{ctx};
626
10
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
10
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_non_empty_domain_var_size_from_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const*, unsigned long long*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const*, unsigned long long*, unsigned long long*)
Line
Count
Source
624
10
      tiledb_ctx_handle_t* ctx, Args... args) {
625
10
    tiledb::api::ExceptionActionCtx action{ctx};
626
10
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
10
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_non_empty_domain_var_from_index(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, void*, void*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, void*, void*)
Line
Count
Source
624
8
      tiledb_ctx_handle_t* ctx, Args... args) {
625
8
    tiledb::api::ExceptionActionCtx action{ctx};
626
8
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
8
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_non_empty_domain_var_from_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const*, void*, void*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const*, void*, void*)
Line
Count
Source
624
8
      tiledb_ctx_handle_t* ctx, Args... args) {
625
8
    tiledb::api::ExceptionActionCtx action{ctx};
626
8
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
8
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_mbr_num(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned long long*)
Line
Count
Source
624
32
      tiledb_ctx_handle_t* ctx, Args... args) {
625
32
    tiledb::api::ExceptionActionCtx action{ctx};
626
32
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
32
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_mbr_from_index(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, unsigned int, void*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, unsigned int, void*)
Line
Count
Source
624
14
      tiledb_ctx_handle_t* ctx, Args... args) {
625
14
    tiledb::api::ExceptionActionCtx action{ctx};
626
14
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
14
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_mbr_from_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, char const*, void*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, char const*, void*)
Line
Count
Source
624
14
      tiledb_ctx_handle_t* ctx, Args... args) {
625
14
    tiledb::api::ExceptionActionCtx action{ctx};
626
14
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
14
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_mbr_var_size_from_index(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, unsigned int, unsigned long long*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, unsigned int, unsigned long long*, unsigned long long*)
Line
Count
Source
624
4
      tiledb_ctx_handle_t* ctx, Args... args) {
625
4
    tiledb::api::ExceptionActionCtx action{ctx};
626
4
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
4
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_mbr_var_size_from_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, char const*, unsigned long long*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, char const*, unsigned long long*, unsigned long long*)
Line
Count
Source
624
4
      tiledb_ctx_handle_t* ctx, Args... args) {
625
4
    tiledb::api::ExceptionActionCtx action{ctx};
626
4
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
4
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_mbr_var_from_index(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, unsigned int, void*, void*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, unsigned int, void*, void*)
Line
Count
Source
624
4
      tiledb_ctx_handle_t* ctx, Args... args) {
625
4
    tiledb::api::ExceptionActionCtx action{ctx};
626
4
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
4
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_mbr_var_from_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, char const*, void*, void*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int, char const*, void*, void*)
Line
Count
Source
624
4
      tiledb_ctx_handle_t* ctx, Args... args) {
625
4
    tiledb::api::ExceptionActionCtx action{ctx};
626
4
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
4
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_cell_num(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned long long*)
Line
Count
Source
624
20
      tiledb_ctx_handle_t* ctx, Args... args) {
625
20
    tiledb::api::ExceptionActionCtx action{ctx};
626
20
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
20
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_total_cell_num(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned long long*)
Line
Count
Source
624
8
      tiledb_ctx_handle_t* ctx, Args... args) {
625
8
    tiledb::api::ExceptionActionCtx action{ctx};
626
8
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
8
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_version(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, unsigned int*)
Line
Count
Source
624
14
      tiledb_ctx_handle_t* ctx, Args... args) {
625
14
    tiledb::api::ExceptionActionCtx action{ctx};
626
14
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
14
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_has_consolidated_metadata(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, int*)
Line
Count
Source
624
50
      tiledb_ctx_handle_t* ctx, Args... args) {
625
50
    tiledb::api::ExceptionActionCtx action{ctx};
626
50
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
50
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_unconsolidated_metadata_num(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int*)
Line
Count
Source
624
20
      tiledb_ctx_handle_t* ctx, Args... args) {
625
20
    tiledb::api::ExceptionActionCtx action{ctx};
626
20
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
20
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_to_vacuum_num(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int*)
Line
Count
Source
624
22
      tiledb_ctx_handle_t* ctx, Args... args) {
625
22
    tiledb::api::ExceptionActionCtx action{ctx};
626
22
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
22
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_to_vacuum_uri(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const**)
Line
Count
Source
624
8
      tiledb_ctx_handle_t* ctx, Args... args) {
625
8
    tiledb::api::ExceptionActionCtx action{ctx};
626
8
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
8
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_array_schema(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, tiledb_array_schema_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, tiledb_array_schema_t**)
Line
Count
Source
624
12
      tiledb_ctx_handle_t* ctx, Args... args) {
625
12
    tiledb::api::ExceptionActionCtx action{ctx};
626
12
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
12
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_get_array_schema_name(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t*, unsigned int, char const**)
Line
Count
Source
624
4
      tiledb_ctx_handle_t* ctx, Args... args) {
625
4
    tiledb::api::ExceptionActionCtx action{ctx};
626
4
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
4
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_fragment_info_dump(tiledb_ctx_handle_t*, tiledb_fragment_info_t const*, __sFILE*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_fragment_info_t const*, __sFILE*)
Line
Count
Source
624
8
      tiledb_ctx_handle_t* ctx, Args... args) {
625
8
    tiledb::api::ExceptionActionCtx action{ctx};
626
8
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
8
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_query_get_status_details(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_experimental_query_status_details_t*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_query_t*, tiledb_experimental_query_status_details_t*)
Line
Count
Source
624
56
      tiledb_ctx_handle_t* ctx, Args... args) {
625
56
    tiledb::api::ExceptionActionCtx action{ctx};
626
56
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
56
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_consolidation_plan_create_with_mbr(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long, tiledb_consolidation_plan_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_array_t*, unsigned long long, tiledb_consolidation_plan_t**)
Line
Count
Source
624
12
      tiledb_ctx_handle_t* ctx, Args... args) {
625
12
    tiledb::api::ExceptionActionCtx action{ctx};
626
12
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
12
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_consolidation_plan_get_num_nodes(tiledb_ctx_handle_t*, tiledb_consolidation_plan_t*, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_consolidation_plan_t*, unsigned long long*)
Line
Count
Source
624
30
      tiledb_ctx_handle_t* ctx, Args... args) {
625
30
    tiledb::api::ExceptionActionCtx action{ctx};
626
30
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
30
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_consolidation_plan_get_num_fragments(tiledb_ctx_handle_t*, tiledb_consolidation_plan_t*, unsigned long long, unsigned long long*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_consolidation_plan_t*, unsigned long long, unsigned long long*)
Line
Count
Source
624
116
      tiledb_ctx_handle_t* ctx, Args... args) {
625
116
    tiledb::api::ExceptionActionCtx action{ctx};
626
116
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
116
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_consolidation_plan_get_fragment_uri(tiledb_ctx_handle_t*, tiledb_consolidation_plan_t*, unsigned long long, unsigned long long, char const**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_consolidation_plan_t*, unsigned long long, unsigned long long, char const**)
Line
Count
Source
624
24
      tiledb_ctx_handle_t* ctx, Args... args) {
625
24
    tiledb::api::ExceptionActionCtx action{ctx};
626
24
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
24
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_consolidation_plan_dump_json_str(tiledb_ctx_handle_t*, tiledb_consolidation_plan_t const*, char**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_consolidation_plan_t const*, char**)
Line
Count
Source
624
2
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2
    tiledb::api::ExceptionActionCtx action{ctx};
626
2
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2
  }
tiledb::api::CAPIFunctionContext<&(tiledb::common::detail::tiledb_filestore_schema_create(tiledb_ctx_handle_t*, char const*, tiledb_array_schema_t**))>::function_with_context(tiledb_ctx_handle_t*, char const*, tiledb_array_schema_t**)
Line
Count
Source
624
8
      tiledb_ctx_handle_t* ctx, Args... args) {
625
8
    tiledb::api::ExceptionActionCtx action{ctx};
626
8
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
8
  }
tiledb::api::CAPIFunctionContext<&(tiledb::common::detail::tiledb_filestore_uri_import(tiledb_ctx_handle_t*, char const*, char const*, tiledb_mime_type_t))>::function_with_context(tiledb_ctx_handle_t*, char const*, char const*, tiledb_mime_type_t)
Line
Count
Source
624
2
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2
    tiledb::api::ExceptionActionCtx action{ctx};
626
2
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2
  }
tiledb::api::CAPIFunctionContext<&(tiledb::common::detail::tiledb_filestore_uri_export(tiledb_ctx_handle_t*, char const*, char const*))>::function_with_context(tiledb_ctx_handle_t*, char const*, char const*)
Line
Count
Source
624
2
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2
    tiledb::api::ExceptionActionCtx action{ctx};
626
2
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2
  }
tiledb::api::CAPIFunctionContext<&(tiledb::common::detail::tiledb_filestore_buffer_import(tiledb_ctx_handle_t*, char const*, void*, unsigned long, tiledb_mime_type_t))>::function_with_context(tiledb_ctx_handle_t*, char const*, void*, unsigned long, tiledb_mime_type_t)
Line
Count
Source
624
2
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2
    tiledb::api::ExceptionActionCtx action{ctx};
626
2
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2
  }
tiledb::api::CAPIFunctionContext<&(tiledb::common::detail::tiledb_filestore_buffer_export(tiledb_ctx_handle_t*, char const*, unsigned long, void*, unsigned long))>::function_with_context(tiledb_ctx_handle_t*, char const*, unsigned long, void*, unsigned long)
Line
Count
Source
624
2
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2
    tiledb::api::ExceptionActionCtx action{ctx};
626
2
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2
  }
tiledb::api::CAPIFunctionContext<&(tiledb::common::detail::tiledb_filestore_size(tiledb_ctx_handle_t*, char const*, unsigned long*))>::function_with_context(tiledb_ctx_handle_t*, char const*, unsigned long*)
Line
Count
Source
624
2
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2
    tiledb::api::ExceptionActionCtx action{ctx};
626
2
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_ctx_get_stats(tiledb_ctx_handle_t*, char**))>::function_with_context(tiledb_ctx_handle_t*, char**)
Line
Count
Source
624
2
      tiledb_ctx_handle_t* ctx, Args... args) {
625
2
    tiledb::api::ExceptionActionCtx action{ctx};
626
2
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
2
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_ctx_get_config(tiledb_ctx_handle_t*, tiledb_config_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_config_handle_t**)
Line
Count
Source
624
785
      tiledb_ctx_handle_t* ctx, Args... args) {
625
785
    tiledb::api::ExceptionActionCtx action{ctx};
626
785
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
785
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_ctx_get_last_error(tiledb_ctx_handle_t*, tiledb_error_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_error_handle_t**)
Line
Count
Source
624
412
      tiledb_ctx_handle_t* ctx, Args... args) {
625
412
    tiledb::api::ExceptionActionCtx action{ctx};
626
412
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
412
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_ctx_is_supported_fs(tiledb_ctx_handle_t*, tiledb_filesystem_t, int*))>::function_with_context(tiledb_ctx_handle_t*, tiledb_filesystem_t, int*)
Line
Count
Source
624
1.95k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
1.95k
    tiledb::api::ExceptionActionCtx action{ctx};
626
1.95k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
1.95k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_ctx_cancel_tasks(tiledb_ctx_handle_t*))>::function_with_context(tiledb_ctx_handle_t*)
Line
Count
Source
624
39
      tiledb_ctx_handle_t* ctx, Args... args) {
625
39
    tiledb::api::ExceptionActionCtx action{ctx};
626
39
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
39
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_ctx_set_tag(tiledb_ctx_handle_t*, char const*, char const*))>::function_with_context(tiledb_ctx_handle_t*, char const*, char const*)
Line
Count
Source
624
5.81k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
5.81k
    tiledb::api::ExceptionActionCtx action{ctx};
626
5.81k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
5.81k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_filter_alloc(tiledb_ctx_handle_t*, tiledb_filter_type_t, tiledb_filter_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_filter_type_t, tiledb_filter_handle_t**)
Line
Count
Source
624
3.26k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
3.26k
    tiledb::api::ExceptionActionCtx action{ctx};
626
3.26k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
3.26k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_filter_list_alloc(tiledb_ctx_handle_t*, tiledb_filter_list_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, tiledb_filter_list_handle_t**)
Line
Count
Source
624
3.24k
      tiledb_ctx_handle_t* ctx, Args... args) {
625
3.24k
    tiledb::api::ExceptionActionCtx action{ctx};
626
3.24k
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
3.24k
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_group_create(tiledb_ctx_handle_t*, char const*))>::function_with_context(tiledb_ctx_handle_t*, char const*)
Line
Count
Source
624
41
      tiledb_ctx_handle_t* ctx, Args... args) {
625
41
    tiledb::api::ExceptionActionCtx action{ctx};
626
41
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
41
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_group_alloc(tiledb_ctx_handle_t*, char const*, tiledb_group_handle_t**))>::function_with_context(tiledb_ctx_handle_t*, char const*, tiledb_group_handle_t**)
Line
Count
Source
624
47
      tiledb_ctx_handle_t* ctx, Args... args) {
625
47
    tiledb::api::ExceptionActionCtx action{ctx};
626
47
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
47
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_group_consolidate_metadata(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*))>::function_with_context(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)
Line
Count
Source
624
6
      tiledb_ctx_handle_t* ctx, Args... args) {
625
6
    tiledb::api::ExceptionActionCtx action{ctx};
626
6
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
6
  }
tiledb::api::CAPIFunctionContext<&(tiledb::api::tiledb_group_vacuum_metadata(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*))>::function_with_context(tiledb_ctx_handle_t*, char const*, tiledb_config_handle_t*)
Line
Count
Source
624
3
      tiledb_ctx_handle_t* ctx, Args... args) {
625
3
    tiledb::api::ExceptionActionCtx action{ctx};
626
3
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
3
  }
tiledb::api::CAPIFunctionContext<&(tf_context_assign(tiledb_ctx_handle_t*, int, int*))>::function_with_context(tiledb_ctx_handle_t*, int, int*)
Line
Count
Source
624
1
      tiledb_ctx_handle_t* ctx, Args... args) {
625
1
    tiledb::api::ExceptionActionCtx action{ctx};
626
1
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
1
  }
tiledb::api::CAPIFunctionContext<&(tf_context_throw(tiledb_ctx_handle_t*))>::function_with_context(tiledb_ctx_handle_t*)
Line
Count
Source
624
1
      tiledb_ctx_handle_t* ctx, Args... args) {
625
1
    tiledb::api::ExceptionActionCtx action{ctx};
626
1
    return CAPIFunction<f, ExceptionActionCtx>::function(action, ctx, args...);
627
1
  }
628
};
629
630
/**
631
 * API function transformer changes an implementation function with a context as
632
 * its first argument into an API function with the same signature.
633
 *
634
 * @tparam f An API implementation function
635
 */
636
template <auto f>
637
constexpr auto api_entry_with_context =
638
    CAPIFunctionContext<f>::function_with_context;
639
640
/**
641
 * API function transformer changes an implementation function without a context
642
 * argument to an API interface function with such an argument prepended.
643
 *
644
 * @tparam f An API implementation function
645
 */
646
template <auto f>
647
constexpr auto api_entry_context =
648
    CAPIFunction<f, ExceptionActionErr>::function_context;
649
650
/**
651
 * API function transformer changes an implementation function without an error
652
 * argument to an API interface function with such an argument prepended.
653
 *
654
 * @tparam f An API implementation function
655
 */
656
template <auto f>
657
constexpr auto api_entry_error =
658
    CAPIFunction<f, ExceptionActionErr>::function_error;
659
660
}  // namespace tiledb::api
661
662
#endif  // TILEDB_C_API_SUPPORT_EXCEPTION_WRAPPER_H